﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using itau.im.entidade;
using EnterpriseLibraryWrapper;
using System.Data;

namespace itau.im.dado
{
    public class CurvaDB : ICurvaDAO
    {
        #region Métodos

        public List<Curva> ObterCurvasPorCodigoGrupoParametros(int codigoGrupoParametro, DateTime dataBase)
        {
            List<Curva> lista = new List<Curva>();
            IDataAccessWrapper data = null;
            DataSet ds;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();
                data.ParameterIn.Add(new ParameterInWrapper("@COD_GRUP_PARM_ATR", codigoGrupoParametro, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@DAT_HOR_EXEO_CUR", dataBase, DbType.DateTime));
                ds = data.ExecuteDataSet("DB2IM.IM0SRT");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        lista.Add(EntidadeFactory.getCurvaPorCodigoGrupoParametros(linha));
                    }
                }

                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                lista = null;
                data.Dispose();
                data = null;
                ds = null;
            }

            return new List<Curva>();
        }

        public IList<TipoCurva> ObterTiposCurva()
        {
            List<TipoCurva> lista = new List<TipoCurva>();
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                DataSet ds = data.ExecuteDataSet("DB2IM.IMSIE");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        lista.Add(EntidadeFactory.getTipoCurva(linha));
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }

            return lista;
        }

        public IList<Situacao> ObterSituacoes()
        {
            List<Situacao> lista = new List<Situacao>();
            IDataAccessWrapper data = null;
            DataSet ds;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                ds = data.ExecuteDataSet("DB2IM.IMSIM");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        lista.Add(EntidadeFactory.getSituacao(linha));
                    }
                }

                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                lista = null;
                data.Dispose();
                data = null;
                ds = null;
            }

            return new List<Situacao>();
        }

        public int ObterMaximoDiasExtensaoCurva()
        {
            IDataAccessWrapper data = null;
            int maximoDias = 0;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterOut.Add(new ParameterOutWrapper("@QTD_DIA_EXTE", DbType.Int32, 4));
                data.ExecuteNonQuery("DB2IM.IM0SAC");

                maximoDias = Convert.ToInt32(data.ParameterOut[0].ParameterValue);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }

            return maximoDias;
        }

        public IList<GradeExecucaoCurva> ObterGradesExecucaoCurva()
        {
            List<GradeExecucaoCurva> lista = new List<GradeExecucaoCurva>();
            IDataAccessWrapper data = null;
            IConfiguracoesDAO configuracoes;
            string dataMaisJanela;
            object ultimaHoraExecucao;
            DataSet ds;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@TXT_DOMN_PARAM", "IM", DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@NOM_PARAM", "UltimaHoraExecucaoAgendador", DbType.String));
                data.ParameterOut.Add(new ParameterOutWrapper("@VLR_PARAM", DbType.AnsiStringFixedLength, 10));

                data.ExecuteNonQuery("DB2IM.IMS48");

                ultimaHoraExecucao = data.ParameterOut[0].ParameterValue;

                data.ParameterIn.Clear();
                data.ParameterOut.Clear();

                configuracoes = DaoFactory.getConfiguracoesDAO();
                // TODO REMOVER
                List<Item> valores = configuracoes.ObterMapaConfiguracoesPorDominio("AGENDADOR");

                dataMaisJanela = System.DateTime.Now.AddSeconds(Convert.ToDouble(valores.Find(prop => prop.Chave.Equals("JANELAAGENDADOR")).Valor)).ToString("yyyyMMddHHmmss");

                data.ParameterIn.Add(new ParameterInWrapper("@HORULTEXEC", ultimaHoraExecucao, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@AGORMAISJANL", dataMaisJanela, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@CODSITINI", 11, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@CODSITFIM", 15, DbType.Int32));

                ds = data.ExecuteDataSet("DB2IM.IMSEZ");

                data.ParameterIn.Clear();

                foreach (DataRow linha in ds.Tables[0].Rows)
                {
                    lista.Add(EntidadeFactory.getGradeExecucaoCurva(linha));
                }

                foreach (GradeExecucaoCurva item in lista)
                {
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", item.CodigoCurva, DbType.Int32));
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_GRDE_EXEO_CUR", item.CodigoGradeExecucaoCurva, DbType.Int32));

                    ds = data.ExecuteDataSet("DB2IM.IMSEW");

                    item.registroGradeExecucaoCurva = new List<RegistroGradeExecucaoCurva>();

                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        item.registroGradeExecucaoCurva.Add(EntidadeFactory.getRegistroGradeExecucaoCurva(linha));
                    }
                }

                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Finaliza os objetos
                lista = null;
                data.Dispose();
                data = null;
                ds = null;
            }

            //Retorna a consulta
            return new List<GradeExecucaoCurva>();
        }

        public GradeExecucaoCurva ObterGradeExecucaoCurva(int curvaID)
        {
            GradeExecucaoCurva gradeExecucaoCurva;
            IDataAccessWrapper data = null;
            DataSet ds;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();
                gradeExecucaoCurva = new GradeExecucaoCurva();

                //Parametro de Entrada 
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_EXEO_GRD", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@HOR_INIO", DbType.Time, 8));
                data.ParameterOut.Add(new ParameterOutWrapper("@HOR_FIM", DbType.Time, 8));
                data.ParameterOut.Add(new ParameterOutWrapper("@QTD_TEMP", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_UNID_TEMP", DbType.Int16, 2));

                //Recupera a consulta
                ds = data.ExecuteParameterToDataSet("DB2IM.IMSEV");
                //Limpa Lista de Parametros
                data.ParameterIn.Clear();
                data.ParameterOut.Clear();

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Adiciona os valores no objeto
                    gradeExecucaoCurva = EntidadeFactory.getGradeExecucaoCurva(ds.Tables[0].Rows[0]);
                }

                return gradeExecucaoCurva;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Finaliza os objetos
                data.Dispose();
                data = null;
                ds = null;
            }

            return new GradeExecucaoCurva();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método que será implementado para retornar a consulta.                          <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "TipoTaxa".</returns>
        public IList<TipoTaxa> ObterTiposTaxa()
        {
            //Declara e instancia o objeto
            List<TipoTaxa> lista = new List<TipoTaxa>();
            IDataAccessWrapper data = null;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Recupera a consulta
                //DataSet ds = data.ExecuteDataSet("DB2IM.IMSIK");
                //Código 5 - interpolação
                data.ParameterIn.Add(new ParameterInWrapper("WCOD_TIPO_PONT_CU", 5, DbType.Int16));
                DataSet ds = data.ExecuteDataSet("DB2IM.IMSIR");

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        lista.Add(EntidadeFactory.getTipoTaxa(linha));
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }

            //Retorna a consulta
            return lista;
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método que será implementado para retornar a consulta.                          <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "TipoEntradaDado".</returns>
        public IList<TipoEntradaDado> ObterTiposEntradaDado()
        {
            //Declara e instancia o objeto
            List<TipoEntradaDado> lista = new List<TipoEntradaDado>();
            IDataAccessWrapper data = null;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Recupera a consulta
                DataSet ds = data.ExecuteDataSet("DB2IM.IMSIL");

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        lista.Add(EntidadeFactory.getTipoEntradaDado(linha));
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }

            //Retorna a consulta
            return lista;
        }

        public Curva ObterCurva(int curvaID)
        {
            Curva objCurva = null;
            DataSet ds;
            IDataAccessWrapper data = null;
            List<TaxaPontoCurvaVigente> listaTaxaPontoCurvaVigente;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));
                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_INRN_CURV", DbType.String, 15));
                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_CURV", DbType.String, 80));
                data.ParameterOut.Add(new ParameterOutWrapper("@DES_CURV", DbType.String, 120));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MODA_CURV", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CATE_MERC", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_SITU", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_CURV", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_SUB_MESA_OPER", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MESA_OPER_TES", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@QTD_ANO_EXTE", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@DAT_ULTI_ALTE", DbType.DateTime, 26));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_LIBE_AUTA", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_PMTE_VERS", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_TRCI_CURV", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_CURV_PAD", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CLAF_CURV", DbType.Int16, 2));

                ds = data.ExecuteParameterToDataSet("DB2IM.IMSFI");
                //Limpa Lista de Parametros
                data.ParameterIn.Clear();
                data.ParameterOut.Clear();

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Adiciona os valores no objeto
                    objCurva = EntidadeFactory.getObterCurva(ds.Tables[0].Rows[0]);

                    //Verifica se é válido
                    if (objCurva != null)
                    {
                        //Parametro de Entrada 
                        data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));
                        data.ParameterOut.Add(new ParameterOutWrapper("@DAT_INCU_VIGE", DbType.DateTime, 26));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_MODE_CALC", DbType.Int32, 4));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_ENTR_DADO", DbType.Int16, 2));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_PRZ", DbType.Int16, 2));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_PRZ_ENTR", DbType.Int16, 2));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_MOED", DbType.Int16, 2));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_TXA", DbType.Int16, 2));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_MODE_INTV_TOLE", DbType.Int32, 4));
                        data.ParameterOut.Add(new ParameterOutWrapper("@DAT_INIO_CURV_VIGE", DbType.DateTime, 26));
                        data.ParameterOut.Add(new ParameterOutWrapper("@DAT_FIM_CURV_VIGE", DbType.DateTime, 26));
                        data.ParameterOut.Add(new ParameterOutWrapper("@IND_PMRO_FATR_1", DbType.Int16, 2));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_CURV_BASE_PMT", DbType.Int32, 4));
                        data.ParameterOut.Add(new ParameterOutWrapper("@IND_PMRO_LIBR_DFL", DbType.Int16, 2));

                        //Recupera a consulta
                        ds = data.ExecuteParameterToDataSet("DB2IM.IMS10");
                        //Limpa Lista de Parametros
                        data.ParameterIn.Clear();
                        data.ParameterOut.Clear();

                        //Verifica se é válido
                        if (ds != null && ds.Tables.Count > 0
                            && ds.Tables[0].Rows.Count > 0)
                        {
                            //Adiciona os valores no objeto
                            objCurva.CurvaVigente = EntidadeFactory.getCurvaVigente(ds.Tables[0].Rows[0]);

                            //Segundo a orientação da Aleksandra, codigo Praça Calendario fixo 1
                            objCurva.CurvaVigente.CodigoPraca = 1;
                        }

                        //Verifica se é válido
                        if (objCurva.CurvaVigente != null)
                        {
                            //Parametro de Entrada 
                            data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));
                            data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", objCurva.CurvaVigente.DataInclusao, DbType.DateTime));

                            //Recupera a consulta
                            ds = data.ExecuteDataSet("DB2IM.IMSEK");

                            //Limpa Lista de Parametros
                            data.ParameterIn.Clear();
                            data.ParameterOut.Clear();

                            if (ds != null && ds.Tables.Count > 0)
                            {
                                //Instância a lista
                                listaTaxaPontoCurvaVigente = new List<TaxaPontoCurvaVigente>();

                                //Percorre todos os registros da tabela
                                foreach (DataRow linha in ds.Tables[0].Rows)
                                {
                                    //Adiciona os valores no objeto
                                    listaTaxaPontoCurvaVigente.Add(EntidadeFactory.getTaxaPontoCurvaVigente(linha));
                                }

                                //Configura o retorno
                                objCurva.CurvaVigente.lstTaxaPontoCurvaVigente = listaTaxaPontoCurvaVigente;
                            }

                            //Parametro de Entrada 
                            data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));
                            data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", objCurva.CurvaVigente.DataInclusao, DbType.DateTime));
                            data.ParameterOut.Add(new ParameterOutWrapper("@COD_CURV_SUCE", DbType.Int32, 4));

                            //Recupera a consulta
                            ds = data.ExecuteParameterToDataSet("DB2IM.IMS41");

                            //Limpa Lista de Parametros
                            data.ParameterIn.Clear();
                            data.ParameterOut.Clear();

                            //Verifica se é válido o retorno
                            if (ds != null && ds.Tables.Count > 0
                                && ds.Tables[0].Rows.Count > 0)
                            {
                                //Adiciona os valores no objeto
                                objCurva.CurvaVigente.CurvaSucessora = (EntidadeFactory.getCurvaSucessora(ds.Tables[0].Rows[0]));
                            }

                            //Verifica se é válido
                            if (objCurva.CurvaVigente.CurvaSucessora != null)
                            {
                                //Parametro de Entrada 
                                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", objCurva.CurvaVigente.CurvaSucessora.CodigoCurvaSucessora, DbType.Int32));
                                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_INRN_CURV", DbType.String, 15));
                                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_CURV", DbType.String, 80));
                                data.ParameterOut.Add(new ParameterOutWrapper("@DES_CURV", DbType.String, 120));
                                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MODA_CURV", DbType.Int16, 2));
                                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CATE_MERC", DbType.Int16, 2));
                                data.ParameterOut.Add(new ParameterOutWrapper("@COD_SITU", DbType.Int16, 2));
                                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_CURV", DbType.Int16, 2));
                                data.ParameterOut.Add(new ParameterOutWrapper("@COD_SUB_MESA_OPER", DbType.Int16, 2));
                                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MESA_OPER_TES", DbType.Int16, 2));
                                data.ParameterOut.Add(new ParameterOutWrapper("@QTD_ANO_EXTE", DbType.Int16, 2));
                                data.ParameterOut.Add(new ParameterOutWrapper("@DAT_ULTI_ALTE", DbType.DateTime, 26));
                                data.ParameterOut.Add(new ParameterOutWrapper("@IND_LIBE_AUTA", DbType.Int16, 2));
                                data.ParameterOut.Add(new ParameterOutWrapper("@IND_PMTE_VERS", DbType.Int16, 2));
                                data.ParameterOut.Add(new ParameterOutWrapper("@IND_TRCI_CURV", DbType.Int16, 2));
                                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_CURV_PAD", DbType.Int16, 2));
                                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CLAF_CURV", DbType.Int16, 2));

                                //Recupera a consulta
                                ds = data.ExecuteParameterToDataSet("DB2IM.IMSFI");

                                //Limpa Lista de Parametros
                                data.ParameterIn.Clear();
                                data.ParameterOut.Clear();

                                //Verifica se é válido o retorno
                                if (ds != null && ds.Tables.Count > 0
                                    && ds.Tables[0].Rows.Count > 0)
                                {
                                    Curva curva = EntidadeFactory.getObterCurva(ds.Tables[0].Rows[0]);
                                    CurvaSucessora curvaSucessora = new CurvaSucessora();
                                    curvaSucessora.CodigoCurva = curva.CodigoCurva;
                                    curvaSucessora.NomeCurva = curva.NomeCurva;
                                    objCurva.CurvaVigente.Curva = curvaSucessora;

                                    //Adiciona os valores no objeto
                                    // TODO remover
                                    //objCurva.CurvaVigente.Curva.CodigoCurva = Convert.ToInt32(ds.Tables[0].Rows[0]["COD_CURV"]);
                                }
                            }

                            //Carrega dados de curva composta
                            if (objCurva.CurvaVigente.CodigoTipoEntradaDado == 1)
                            {
                                //Parametro de Entrada 
                                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));
                                data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", objCurva.CurvaVigente.DataInclusao, DbType.DateTime));
                                data.ParameterOut.Add(new ParameterOutWrapper("@DES_FORU_CPSC", DbType.String, 100));

                                //Recupera a consulta
                                ds = data.ExecuteParameterToDataSet("DB2IM.IMSIV");

                                //Limpa Lista de Parametros
                                data.ParameterIn.Clear();
                                data.ParameterOut.Clear();

                                //Verifica se é válido o retorno
                                if (ds != null && ds.Tables.Count > 0
                                    && ds.Tables[0].Rows.Count > 0)
                                    //Recupera o objeto
                                    objCurva.CurvaVigente.ComposicaoCurva = EntidadeFactory.getComposicaoCurva(ds.Tables[0].Rows[0]);

                            }

                            //Parametro de Entrada 
                            data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));
                            data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_EXEO_GRD", DbType.Int16, 2));
                            data.ParameterOut.Add(new ParameterOutWrapper("@HOR_INIO", DbType.Time, 8));
                            data.ParameterOut.Add(new ParameterOutWrapper("@HOR_FIM", DbType.Time, 8));
                            data.ParameterOut.Add(new ParameterOutWrapper("@QTD_TEMP", DbType.Int16, 2));
                            data.ParameterOut.Add(new ParameterOutWrapper("@COD_UNID_TEMP", DbType.Int16, 2));

                            //Recupera a consulta
                            ds = data.ExecuteParameterToDataSet("DB2IM.IMSEV");
                            //Limpa Lista de Parametros
                            data.ParameterIn.Clear();
                            data.ParameterOut.Clear();

                            if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                            {
                                //Adiciona os valores no objeto
                                objCurva.GradeExecucaoCurva = EntidadeFactory.getGradeExecucaoCurva(ds.Tables[0].Rows[0]);
                            }

                            //Veririfica se é válido
                            if (objCurva.GradeExecucaoCurva != null)
                            {
                                //Parametro de Entrada 
                                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));

                                //Recupera a consulta
                                ds = data.ExecuteDataSet("DB2IM.IMSEW");

                                //Limpa Lista de Parametros
                                data.ParameterIn.Clear();
                                data.ParameterOut.Clear();

                                //Instância a lista
                                objCurva.GradeExecucaoCurva.registroGradeExecucaoCurva = new List<RegistroGradeExecucaoCurva>();

                                if (ds.Tables.Count > 0)
                                {
                                    //Percorre todos os registros da tabela
                                    foreach (DataRow linha in ds.Tables[0].Rows)
                                    {
                                        //Recupera os itens
                                        objCurva.GradeExecucaoCurva.registroGradeExecucaoCurva.Add(EntidadeFactory.getRegistroGradeExecucaoCurva(linha));
                                    }
                                }
                            }

                            //Verifica se é válido
                            if (objCurva.CurvaVigente.ComposicaoCurva != null)
                            {

                                //Parametro de Entrada 
                                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));
                                data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", objCurva.CurvaVigente.DataInclusao, DbType.DateTime));

                                //Recupera a consulta
                                ds = data.ExecuteDataSet("DB2IM.IMSIW");

                                //Limpa Lista de Parametros
                                data.ParameterIn.Clear();
                                data.ParameterOut.Clear();

                                //Instância a lista
                                objCurva.CurvaVigente.ComposicaoCurva.Itens = new List<ItemComposicao>();

                                if (ds != null && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                                {

                                    //Percorre todos os registros da tabela
                                    foreach (DataRow linha in ds.Tables[0].Rows)
                                    {
                                        //Adiciona o item
                                        objCurva.CurvaVigente.ComposicaoCurva.Itens.Add(EntidadeFactory.getItemComposicaoCurva(linha));
                                    }
                                }
                            }

                            //Carrega dados de importacao de arquivo
                            if (objCurva.CurvaVigente.CodigoTipoEntradaDado == 3)
                            {
                                //Parametro de Entrada 
                                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));
                                data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", objCurva.CurvaVigente.DataInclusao, DbType.DateTime));
                                data.ParameterOut.Add(new ParameterOutWrapper("@SIG_TIPO_ARQU", DbType.String, 4));
                                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_DRTO", DbType.String, 100));
                                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_ARQU", DbType.String, 30));
                                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_PNLH", DbType.String, 30));
                                data.ParameterOut.Add(new ParameterOutWrapper("@IND_VLDO_DAT_RFRC", DbType.String, 1));
                                data.ParameterOut.Add(new ParameterOutWrapper("@IND_VLDO_NOM_ARQU", DbType.String, 1));

                                //Recupera a consulta
                                ds = data.ExecuteParameterToDataSet("DB2IM.IM0SPB");

                                //Limpa Lista de Parametros
                                data.ParameterIn.Clear();
                                data.ParameterOut.Clear();

                                //Verifica se é válido o retorno
                                if (ds != null && ds.Tables.Count > 0
                                    && ds.Tables[0].Rows.Count > 0)
                                    //Recupera o objeto
                                    objCurva.CurvaVigente.ImportacaoArquivo = EntidadeFactory.getImportacaoArquivo(ds.Tables[0].Rows[0]);

                            }

                            //Parametro de Entrada                             
                            data.ParameterIn.Add(new ParameterInWrapper("@COD_MODE_INTV_TOL", objCurva.CurvaVigente.CodigoModeloIntervaloTolerancia, DbType.Int32));
                            data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_INTV_TOL", DbType.Int16, 2));
                            data.ParameterOut.Add(new ParameterOutWrapper("@COD_ACAO_RETE", DbType.Int16, 2));
                            data.ParameterOut.Add(new ParameterOutWrapper("@NOM_MODE_INTV_TOL", DbType.String, 30));
                            data.ParameterOut.Add(new ParameterOutWrapper("@DES_MODE_INTV_TOL", DbType.String, 100));

                            //Recupera a consulta
                            ds = data.ExecuteParameterToDataSet("DB2IM.IMS08");

                            //Limpa Lista de Parametros
                            data.ParameterIn.Clear();
                            data.ParameterOut.Clear();

                            //Verifica se é válido o retorno
                            if (ds != null && ds.Tables.Count > 0
                                && ds.Tables[0].Rows.Count > 0)
                                //Recupera o objeto
                                objCurva.CurvaVigente.ModeloIntervaloTolerancia = EntidadeFactory.getModeloIntervaloToleranciaParametro(ds.Tables[0].Rows[0]);


                            //Verifica se é válida
                            if (objCurva.CurvaVigente.ModeloIntervaloTolerancia != null)
                            {
                                //Parametro de Entrada 
                                data.ParameterIn.Add(new ParameterInWrapper("@COD_MODE_INTV_TOL", objCurva.CurvaVigente.CodigoModeloIntervaloTolerancia, DbType.Int32));

                                //Recupera a consulta
                                ds = data.ExecuteDataSet("DB2IM.IMS07");

                                //Limpa Lista de Parametros
                                data.ParameterIn.Clear();

                                //Instância a lista de saída
                                objCurva.CurvaVigente.ModeloIntervaloTolerancia.lstParametroModeloIntervaloTolerancia = new List<ParametroModeloIntervaloTolerancia>();

                                //Percorre todos os registros da tabela
                                foreach (DataRow linha in ds.Tables[0].Rows)
                                {
                                    //Adiciona o item
                                    objCurva.CurvaVigente.ModeloIntervaloTolerancia.lstParametroModeloIntervaloTolerancia.Add(EntidadeFactory.getParametroModeloIntervaloTolerancia(linha));

                                }
                            }
                        }

                        //Retorna a consulta
                        return objCurva;
                    }
                }

            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }

            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }

            finally
            {
                //Desaloca o objeto
                objCurva = null;
                data.Dispose();
                data = null;
                ds = null;
                listaTaxaPontoCurvaVigente = null;
            }

            return new Curva();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método que retornar a consulta.                                                 <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "ModalidadeCurva".</returns>
        public IList<ModalidadeCurva> ObterModalidadesCurva()
        {
            //Declara o objeto
            IList<ModalidadeCurva> lista = new List<ModalidadeCurva>();
            IDataAccessWrapper data = null;
            DataSet ds;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Recupera a consulta
                ds = data.ExecuteDataSet("DB2IM.IMSIF");

                //Verifica se é válido
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre os itens
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Adiciona o item
                        lista.Add(EntidadeFactory.getModalidadeCurva(linha));
                    }
                }
                //Retorna a lista de objetos da consulta
                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Finaliza os objetos
                lista = null;
                data.Dispose();
                data = null;
                ds = null;

            }

            //Retorna lista
            return new List<ModalidadeCurva>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método que retornar a consulta.                                                 <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "TipoTaxa".</returns>
        public IList<TaxaPontoCurva> ObterVerticesInterpolacao()
        {
            //Declara e instancia o objeto
            List<TaxaPontoCurva> lista = new List<TaxaPontoCurva>();
            IDataAccessWrapper data = null;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Recupera a consulta
                //Código 2 - interpolação
                data.ParameterIn.Add(new ParameterInWrapper("WCOD_TIPO_PONT_CU", 4, DbType.Int16));
                DataSet ds = data.ExecuteDataSet("DB2IM.IMSIR");

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        lista.Add(EntidadeFactory.getTaxaPontoCurva(linha));
                    }
                }

                //Retorna a consulta
                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Finaliza os objetos
                lista = null;
                data.Dispose();
                data = null;
            }

            //Retorna
            return new List<TaxaPontoCurva>();

        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método retornar a consulta.                                                     <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "TaxaPontoCurvaVigente".</returns>
        public IList<TaxaPontoCurvaVigente> ObterMetodosInterpolacaoCurva(int curvaID, DateTime dataInclusaoVigencia)
        {
            //Declara e instancia o objeto
            List<TaxaPontoCurvaVigente> lista = new List<TaxaPontoCurvaVigente>();
            IDataAccessWrapper data = null;
            DataSet ds;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //implementar os parâmetros.

                //Parametro de Entrada 
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", dataInclusaoVigencia, DbType.DateTime));

                //Recupera a consulta
                ds = data.ExecuteDataSet("DB2IM.IMSEK");

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        lista.Add(EntidadeFactory.getTaxaPontoCurvaVigente(linha));
                    }
                }

                //Retorna a consulta
                return lista;

            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Finaliza os objetos
                lista = null;
                data.Dispose();
                data = null;
                ds = null;
            }

            //Retorna
            return new List<TaxaPontoCurvaVigente>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método ObterCategoriasMercado.                                                  <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "CategoriaMercado".</returns>
        public IList<CategoriaMercado> ObterCategoriasMercado()
        {
            //Declara e instancia o objeto
            List<CategoriaMercado> listaRetorno = new List<CategoriaMercado>();
            IDataAccessWrapper data = null;
            DataSet dsRetorno;
            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Recupera a consulta
                dsRetorno = data.ExecuteDataSet("DB2IM.IMSIG");

                //Verifica se é válido o retorno
                if (dsRetorno.Tables.Count > 0 && dsRetorno.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in dsRetorno.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        listaRetorno.Add(EntidadeFactory.getCategoriaMercado(linha));
                    }
                }

                //Retorna a consulta
                return listaRetorno;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Desaloca os objetos
                listaRetorno = null;
                data.Dispose();
                data = null;
                dsRetorno = null;
            }

            //Retorna a consulta limpa
            return new List<CategoriaMercado>();

        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método implementado para retornar a consulta.                          <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "TipoPrazo".</returns>
        public IList<TipoPrazo> ObterTiposPrazo()
        {
            //Declara e instancia o objeto
            List<TipoPrazo> lista = new List<TipoPrazo>();
            IDataAccessWrapper data = null;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Recupera a consulta
                DataSet ds = data.ExecuteDataSet("DB2IM.IMSIJ");

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        lista.Add(EntidadeFactory.getTipoPrazo(linha));
                    }
                }

                //Retorna a consulta
                return lista;
            }

            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
                //Desaloca o objeto
                lista = null;
            }

            //Retorna a consulta
            return new List<TipoPrazo>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método implementado para retornar a consulta.                                   <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "TaxaPontoCurva".</returns>
        public IList<TaxaPontoCurva> ObterMetodosExtrapolacao()
        {
            //Declara e instancia o objeto
            List<TaxaPontoCurva> lista = new List<TaxaPontoCurva>();
            IDataAccessWrapper data = null;
            DataSet ds;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Recupera a consulta
                //Código 3 - interpolação
                data.ParameterIn.Add(new ParameterInWrapper("WCOD_TIPO_PONT_CU", 3, DbType.Int16));
                ds = data.ExecuteDataSet("DB2IM.IMSIR");

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        lista.Add(EntidadeFactory.getTaxaPontoCurva(linha));
                    }
                }

                //Retorna a consulta
                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }

            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }

            finally
            {
                //Desaloca o objeto
                lista = null;
                data.Dispose();
                data = null;
                ds = null;
            }

            //Retorna a consulta
            return new List<TaxaPontoCurva>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método implementado para retornar a consulta.                                   <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "Cotacao".</returns>
        public IList<Cotacao> ObterCotacoes()
        {
            //Declara e instancia o objeto
            List<Cotacao> lista = new List<Cotacao>();
            IDataAccessWrapper data = null;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //todo: Conforme resposta do analista, o método em questão não está sendo utilizado nos casos de uso
                //Recupera a consulta
                DataSet ds = data.ExecuteDataSet("");

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        lista.Add(EntidadeFactory.getCotacao(linha));
                    }
                }

                //Retorna a consulta
                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
                lista = null;
            }

            //Retorna a consulta
            return new List<Cotacao>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método ObterMetodosInterpolacao.                                                <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "TipoTaxa".</returns>
        public IList<TaxaPontoCurva> ObterMetodosInterpolacao()
        {
            //Declara e instancia o objeto
            List<TaxaPontoCurva> listaRetorno = new List<TaxaPontoCurva>();
            IDataAccessWrapper data = null;
            DataSet dsRetorno;
            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //TODO:aguardando definicao de proc a ser utilizada
                //Recupera a consulta
                //Código 2 - interpolação
                data.ParameterIn.Add(new ParameterInWrapper("WCOD_TIPO_PONT_CU", 2, DbType.Int16));
                dsRetorno = data.ExecuteDataSet("DB2IM.IMSIR");

                //Verifica se é válido o retorno
                if (dsRetorno.Tables.Count > 0 && dsRetorno.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in dsRetorno.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        listaRetorno.Add(EntidadeFactory.getTaxaPontoCurva(linha));
                    }
                }

                //Retorna a consulta
                return listaRetorno;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Desaloca os objetos
                listaRetorno = null;
                data.Dispose();
                data = null;
                dsRetorno = null;
            }

            //Retorna a consulta limpa
            return new List<TaxaPontoCurva>();

        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método que retorna lista do tipo ModeloCalculo                                  <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "ModeloCalculo".</returns>
        public IList<ModeloCalculo> ObterModelosCalculo()
        {
            //Declara e instancia o objeto
            List<ModeloCalculo> lista = new List<ModeloCalculo>();
            IDataAccessWrapper data = null;
            DataSet ds;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Recupera a consulta
                ds = data.ExecuteDataSet("DB2IM.IMSII");

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        lista.Add(EntidadeFactory.getModeloCalculo(linha));
                    }
                }
                //Retorna a consulta
                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
                ds = null;
                lista = null;
            }

            //Retorna a consulta
            return new List<ModeloCalculo>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método que retorna lista do tipo TipoTaxa                                       <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "TipoTaxa".</returns>
        public IList<TaxaPontoCurva> ObterMetodosAntepolacao()
        {
            //Declara e instancia o objeto
            List<TaxaPontoCurva> lista = new List<TaxaPontoCurva>();
            IDataAccessWrapper data = null;
            DataSet ds;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Recupera a consulta
                //Código 1 - antepolação
                data.ParameterIn.Add(new ParameterInWrapper("WCOD_TIPO_PONT_CU", 1, DbType.Int16));
                ds = data.ExecuteDataSet("DB2IM.IMSIR");

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        lista.Add(EntidadeFactory.getTaxaPontoCurva(linha));
                    }
                }
                //Retorna a consulta
                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Desaloca os objetos
                data.Dispose();
                data = null;
                ds = null;
                lista = null;
            }

            //Retorna a consulta
            return new List<TaxaPontoCurva>();

        }

        public IList<Curva> ObterCurvas()
        {
            List<Curva> lista = new List<Curva>();
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                DataSet ds = data.ExecuteDataSet("DB2IM.IMSIT");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        lista.Add(EntidadeFactory.getCurva(linha));
                    }
                }
                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
                lista = null;
            }

            return new List<Curva>();
        }

        public IList<Curva> ObterCurvasPorTipoEntradaDado(int codTipoEntradaDado)
        {
            List<Curva> lista = new List<Curva>();
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("COD_TIPO_ENTR_DADO", codTipoEntradaDado, DbType.Int16));
                DataSet ds = data.ExecuteDataSet("DB2IM.IM0S8B");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        lista.Add(EntidadeFactory.getCurva(linha));
                    }
                }

                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
                lista = null;
            }

            return new List<Curva>();
        }

        public int ObterMaximoExtensaoAnos()
        {
            try
            {
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
            }

            return 0;
        }

        public Curva ObterDadosBasicosCurva(int codigoCurva)
        {
            Curva curva = new Curva();
            IDataAccessWrapper data = null;
            DataSet dsRetorno;
            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", codigoCurva, DbType.Int32));
                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_INRN_CURV", DbType.String, 15));
                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_CURV", DbType.String, 80));
                data.ParameterOut.Add(new ParameterOutWrapper("@DES_CURV", DbType.String, 120));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MODA_CURV", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CATE_MERC", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_SITU", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_CURV", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_SUB_MESA_OPER", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MESA_OPER_TESO", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@QTD_ANO_EXTE", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@DAT_ULTI_ALTE", DbType.DateTime, 26));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_LIBE_AUTA", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_PMTE_VERS", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_TRCI_CURV", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_CURV_PAD", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CLAF_CURV", DbType.Int16, 2));

                dsRetorno = data.ExecuteParameterToDataSet("DB2IM.IMSFI");

                if (dsRetorno.Tables.Count > 0 && dsRetorno.Tables[0].Rows.Count > 0)
                {
                    curva = EntidadeFactory.getCurva(dsRetorno.Tables[0].Rows[0]);
                }

                return curva;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                curva = null;
                data.Dispose();
                data = null;
                dsRetorno = null;
            }

            return new Curva();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método RemoverCurva.                                                            <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        public void RemoverCurva(Curva curva)
        {
            //Declara e instancia o objeto
            IDataAccessWrapper data = null;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Atualiza a curva com o estado de "inativa"
                curva.CodigoSituacao = 3;

                // Adiciona os parametros de entrada no objeto data.
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@NOM_INRN_CURV", curva.NomeInternoCurva, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@NOM_CURV", curva.NomeCurva, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@DES_CURV", curva.DescricaoCurva, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_MODA_CURV", curva.CodigoModalidadeCurva, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CATE_MERC", curva.CodigoCategoriaMercado, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_SITU", curva.CodigoSituacao, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_CURV", curva.CodigoTipoCurva, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_SUB_MESA_OPER", curva.CodigoSubMesaOperacao, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_MESA_OPER_TESO", curva.CodigoMesaOperacaoTesouraria, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@QTD_ANO_EXTE", curva.QuantidadeAnoExtensao, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@IND_LIBE_AUTA", curva.IndicadorLiberacaoAutomatica, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@IND_PMTE_VERS", curva.IndicadorPermiteVersao, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@IND_TRCI_CURV", curva.IndicadorTerceiraCurva, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_CURV_PAD", curva.CodigoTipoCurvaPadrao, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CLAF_CURV", curva.CodigoClassificacao, DbType.Int16));

                data.ExecuteNonQuery("DB2IM.IMSFH");
                data.ParameterIn.Clear();

                //Verifica se é válido
                if (curva.GradeExecucaoCurva != null)
                {
                    //Verifica se é válido e se tem registros na lista
                    if (curva.GradeExecucaoCurva.registroGradeExecucaoCurva != null &&
                        curva.GradeExecucaoCurva.registroGradeExecucaoCurva.Count > 0)
                    {
                        //Percorre os elementos da lista
                        foreach (RegistroGradeExecucaoCurva registroGrade in curva.GradeExecucaoCurva.registroGradeExecucaoCurva)
                        {
                            //Adiciona os paramentros
                            data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", registroGrade.CodigoCurva, DbType.Int32));

                            data.ExecuteNonQuery("DB2IM.IMS1E");
                            data.ParameterIn.Clear();
                        }
                    }

                    //Adiciona os paramentros
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.GradeExecucaoCurva.CodigoCurva, DbType.Int32));

                    data.ExecuteNonQuery("DB2IM.IMS1D");
                    data.ParameterIn.Clear();
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Desaloca o objeto
                curva = null;
                data.Dispose();
                data = null;
            }
        }

        public void AtualizarCurva(Curva curva)
        {
            IDataAccessWrapper data = null;

            data = EnterpriseLibraryFactory.GetDataAccess();

            try
            {
                data.BeginTransaction();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@NOM_INRN_CURV", curva.NomeInternoCurva, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@NOM_CURV", curva.NomeCurva, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@DES_CURV", curva.DescricaoCurva, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_MODA_CURV", curva.CodigoModalidadeCurva, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CATE_MERC", curva.CodigoCategoriaMercado, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_SITU", curva.CodigoSituacao, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_CURV", curva.CodigoTipoCurva, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_SUB_MESA_OPER", curva.CodigoSubMesaOperacao, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_MESA_OPER_TES", curva.CodigoMesaOperacaoTesouraria, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@QTD_ANO_EXTE", curva.QuantidadeAnoExtensao, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@IND_LIBE_AUTA", curva.IndicadorLiberacaoAutomatica, DbType.Boolean));
                data.ParameterIn.Add(new ParameterInWrapper("@IND_PMTE_VERS", curva.IndicadorPermiteVersao, DbType.Boolean));
                data.ParameterIn.Add(new ParameterInWrapper("@IND_TRCI_CURV", curva.IndicadorTerceiraCurva, DbType.Boolean));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_CURV_PAD", curva.CodigoTipoCurvaPadrao, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CLAF_CURV", curva.CodigoClassificacao, DbType.Int16));

                // Curva
                data.ExecuteNonQuery("DB2IM.IMSFH");
                data.ParameterIn.Clear();

                curva.CurvaVigente.DataFimVigencia = DateTime.Now;

                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", curva.CurvaVigente.DataInclusao, DbType.DateTime));
                data.ParameterIn.Add(new ParameterInWrapper("@DAT_FIM_CURV_VIGE", curva.CurvaVigente.DataFimVigencia, DbType.DateTime));

                data.ExecuteNonQuery("DB2IM.IMSFP");
                data.ParameterIn.Clear();

                curva.CurvaVigente.DataInicioVigencia = curva.CurvaVigente.DataFimVigencia.AddMilliseconds(1);
                curva.CurvaVigente.DataInclusao = curva.CurvaVigente.DataInicioVigencia.AddDays(1);

                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", curva.CurvaVigente.DataInclusao, DbType.DateTime));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_MODE_CALC", curva.CurvaVigente.CodigoModeloCalculo, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_ENTR_DAD", curva.CurvaVigente.CodigoTipoEntradaDado, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_PRZ", curva.CurvaVigente.CodigoTipoPrazo, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_PRZ_ENTR", curva.CurvaVigente.CodigoTipoPrazoEntrada, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_MOED", curva.CurvaVigente.CodigoMoeda, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_TXA", curva.CurvaVigente.CodigoTipoTaxa, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@DAT_INIO_CURV_VIG", curva.CurvaVigente.DataInicioVigencia, DbType.DateTime));
                data.ParameterIn.Add(new ParameterInWrapper("@DAT_FIM_CURV_VIGE", curva.CurvaVigente.DataFimVigencia, DbType.DateTime));
                data.ParameterIn.Add(new ParameterInWrapper("@IND_PMRO_FATR_1", curva.CurvaVigente.IndicadorPrimeiroFator1, DbType.Boolean));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_MODE_INTV_TOL", curva.CurvaVigente.CodigoModeloIntervaloTolerancia, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV_BASE_PMT", curva.CurvaVigente.CodigoCurvaBasePMT, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@IND_PMRO_LIBR_DFL", curva.CurvaVigente.IndicadorPrimeiraDefault, DbType.Int16));

                data.ExecuteNonQuery("DB2IM.IMSFN");
                data.ParameterIn.Clear();

                if (curva.CurvaVigente.lstTaxaPontoCurvaVigente != null
                    && curva.CurvaVigente.lstTaxaPontoCurvaVigente.Count > 0)
                {
                    foreach (TaxaPontoCurvaVigente taxaPontoCurvaVigente in curva.CurvaVigente.lstTaxaPontoCurvaVigente)
                    {
                        data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                        data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_PONT_CUR", taxaPontoCurvaVigente.CodigoTipoPontoCurva, DbType.Int16));
                        data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_TXA", taxaPontoCurvaVigente.CodigoTipoTaxa, DbType.Int16));
                        data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", curva.CurvaVigente.DataInclusao, DbType.DateTime));

                        data.ExecuteNonQuery("DB2IM.IMSHR");
                        data.ParameterIn.Clear();
                    }
                }

                if (curva.CurvaVigente.CodigoTipoEntradaDado == 3
                    && curva.CurvaVigente.ImportacaoArquivo != null
                    && !string.IsNullOrEmpty(curva.CurvaVigente.ImportacaoArquivo.Sigla))
                {
                    curva.CurvaVigente.ImportacaoArquivo.DataInclusaoVigencia = curva.CurvaVigente.DataInclusao;

                    data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                    data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", curva.CurvaVigente.DataInclusao, DbType.DateTime)); //curva.CurvaVigente.ImportacaoArquivo.DataInclusaoVigencia, DbType.DateTime));
                    data.ParameterIn.Add(new ParameterInWrapper("@SIG_TIPO_ARQU", curva.CurvaVigente.ImportacaoArquivo.Sigla, DbType.String));
                    data.ParameterIn.Add(new ParameterInWrapper("@NOM_DRTO", curva.CurvaVigente.ImportacaoArquivo.Diretorio, DbType.String));
                    data.ParameterIn.Add(new ParameterInWrapper("@NOM_ARQU", curva.CurvaVigente.ImportacaoArquivo.NomeArquivo, DbType.String));
                    data.ParameterIn.Add(new ParameterInWrapper("@NOM_PNLH", curva.CurvaVigente.ImportacaoArquivo.NomePlanilha, DbType.String));
                    data.ParameterIn.Add(new ParameterInWrapper("@IND_VLDO_DAT_RFRC", curva.CurvaVigente.ImportacaoArquivo.IndicadorValidacaoData ? "S" : "N", DbType.String));
                    data.ParameterIn.Add(new ParameterInWrapper("@IND_VLDO_NOM_ARQU", curva.CurvaVigente.ImportacaoArquivo.IndicadorValidacaoArquivo ? "S" : "N", DbType.String));

                    data.ExecuteNonQuery("DB2IM.IM0SPA");
                    data.ParameterIn.Clear();
                }

                if (curva.CurvaVigente.CodigoTipoEntradaDado == 1
                    && curva.CurvaVigente.ComposicaoCurva != null
                    && !string.IsNullOrEmpty(curva.CurvaVigente.ComposicaoCurva.FormulaComposicao))
                {
                    curva.CurvaVigente.ComposicaoCurva.DataInclusaoVigencia = curva.CurvaVigente.DataInclusao;

                    data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                    data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", curva.CurvaVigente.DataInclusao, DbType.DateTime));
                    data.ParameterIn.Add(new ParameterInWrapper("@DES_FORU_CPSC", curva.CurvaVigente.ComposicaoCurva.FormulaComposicao, DbType.String));

                    data.ExecuteNonQuery("DB2IM.IMS47");
                    data.ParameterIn.Clear();

                    if (curva.CurvaVigente.ComposicaoCurva.Itens != null &&
                        curva.CurvaVigente.ComposicaoCurva.Itens.Count > 0)
                    {
                        foreach (ItemComposicao item in curva.CurvaVigente.ComposicaoCurva.Itens)
                        {
                            data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                            data.ParameterIn.Add(new ParameterInWrapper("@COD_OPRO_FORU_CPS", item.OperandoFormula, DbType.String));
                            data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", curva.CurvaVigente.DataInclusao, DbType.DateTime));
                            data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_CPSC", item.CodigoTipoComposicao, DbType.Int16));
                            data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV_ITGT", item.CodigoCurvaIntegrante, DbType.Int32));
                            data.ParameterIn.Add(new ParameterInWrapper("@COD_COTC_SRIE_ITG", item.CodigoSerieIntegrante, DbType.Int32));
                            data.ParameterIn.Add(new ParameterInWrapper("@IND_CURV_BASE", item.IndicadorCurvaBase, DbType.Int16));
                            data.ParameterIn.Add(new ParameterInWrapper("@COD_FAMI", item.CodigoFamilia, DbType.Int32));
                            data.ParameterIn.Add(new ParameterInWrapper("@COD_SRIE", item.CodigoSerie, DbType.Int32));
                            data.ParameterIn.Add(new ParameterInWrapper("@COD_ATBT", item.CodigoAtributo, DbType.Int32));
                            data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_ATBT", item.CodigoTipoAtributo, DbType.Int16));

                            data.ExecuteNonQuery("DB2IM.IMSIY");
                            data.ParameterIn.Clear();
                        }
                    }
                }

                if (curva.GradeExecucaoCurva != null
                    && curva.GradeExecucaoCurva.registroGradeExecucaoCurva != null
                    && curva.GradeExecucaoCurva.registroGradeExecucaoCurva.Count > 0
                    && curva.GradeExecucaoCurva.CodigoTipoExecucaoCurva != 2)
                {

                    data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                    data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_EXEO_GRD", DbType.Int16, 2));
                    data.ParameterOut.Add(new ParameterOutWrapper("@HOR_INIO", DbType.Time, 8));
                    data.ParameterOut.Add(new ParameterOutWrapper("@HOR_FIM", DbType.Time, 8));
                    data.ParameterOut.Add(new ParameterOutWrapper("@QTD_TEMP", DbType.Int16, 2));
                    data.ParameterOut.Add(new ParameterOutWrapper("@COD_UNID_TEMP", DbType.Int16, 2));

                    //Recupera a consulta
                    DataSet ds = data.ExecuteParameterToDataSet("DB2IM.IMSEV");
                    data.ParameterIn.Clear();
                    data.ParameterOut.Clear();

                    if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                    {
                        data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                        data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_EXEO_GRD", curva.GradeExecucaoCurva.CodigoTipoExecucaoCurva, DbType.Int16));
                        data.ParameterIn.Add(new ParameterInWrapper("@HOR_INIO", curva.GradeExecucaoCurva.HoraInicio.TimeOfDay, DbType.Time));
                        data.ParameterIn.Add(new ParameterInWrapper("@HOR_FIM", curva.GradeExecucaoCurva.HoraFim.TimeOfDay, DbType.Time));
                        data.ParameterIn.Add(new ParameterInWrapper("@QTD_TEMP", curva.GradeExecucaoCurva.QuantidadeTempo, DbType.Int16));
                        data.ParameterIn.Add(new ParameterInWrapper("@COD_UNID_TEMP", curva.GradeExecucaoCurva.CodigoUnidadeTempo, DbType.Int16));

                        data.ExecuteNonQuery("DB2IM.IMS1B");
                        data.ParameterIn.Clear();
                    }
                    else
                    {
                        data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                        data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_EXEO_GRD", curva.GradeExecucaoCurva.CodigoTipoExecucaoCurva, DbType.Int16));
                        data.ParameterIn.Add(new ParameterInWrapper("@HOR_INIO", curva.GradeExecucaoCurva.HoraInicio.TimeOfDay, DbType.Time));
                        data.ParameterIn.Add(new ParameterInWrapper("@HOR_FIM", curva.GradeExecucaoCurva.HoraFim.TimeOfDay, DbType.Time));
                        data.ParameterIn.Add(new ParameterInWrapper("@QTD_TEMP", curva.GradeExecucaoCurva.QuantidadeTempo, DbType.Int16));
                        data.ParameterIn.Add(new ParameterInWrapper("@COD_UNID_TEMP", curva.GradeExecucaoCurva.CodigoUnidadeTempo, DbType.Int16));

                        data.ExecuteNonQuery("DB2IM.IMSEX");
                        data.ParameterIn.Clear();
                    }

                    data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));

                    data.ExecuteNonQuery("DB2IM.IMS1E");
                    data.ParameterIn.Clear();

                    foreach (RegistroGradeExecucaoCurva item in curva.GradeExecucaoCurva.registroGradeExecucaoCurva)
                    {
                        data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                        data.ParameterIn.Add(new ParameterInWrapper("@NUM_EXEO", item.NumeroExecucao, DbType.Int32));
                        data.ParameterIn.Add(new ParameterInWrapper("@HOR_EXEO", item.HoraExecucao.TimeOfDay, DbType.Time));

                        data.ExecuteNonQuery("DB2IM.IMSEY");
                        data.ParameterIn.Clear();
                    }
                }
                else //Caso nao exista grade de execução, remover os itens existentes.
                {
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                    data.ExecuteNonQuery("DB2IM.IMS1D");
                    data.ParameterIn.Clear();

                    data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));

                    data.ExecuteNonQuery("DB2IM.IMS1E");
                    data.ParameterIn.Clear();
                }


                if (curva.CurvaVigente.Curva != null
                    && curva.CurvaSucessora != null
                    && curva.CurvaSucessora.CodigoCurva != 0)
                {
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                    data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", curva.CurvaVigente.DataInclusao, DbType.DateTime));
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV_SUCE", curva.CurvaSucessora.CodigoCurva, DbType.Int32));

                    data.ExecuteNonQuery("DB2IM.IMSFJ");
                    data.ParameterIn.Clear();
                }

                data.CommitTransaction();
            }
            catch (DadosException ex)
            {
                data.RollBackTransaction();
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                data.RollBackTransaction();
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                curva = null;
                data.Dispose();
                data = null;
            }
        }

        public int CriarRegistroExecucaoCurvaPontos(RegistroExecucaoCurva registroExecucaoCurva)
        {
            IDataAccessWrapper data = null;

            data = EnterpriseLibraryFactory.GetDataAccess();

            try
            {
                data.BeginTransaction();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", registroExecucaoCurva.CodigoCurva, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", registroExecucaoCurva.DataInclusaoVigencia, DbType.DateTime));
                data.ParameterIn.Add(new ParameterInWrapper("@DAT_HOR_EXEO_CURV", registroExecucaoCurva.DataHoraExecucaoCurva, DbType.DateTime));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_SITU", registroExecucaoCurva.CodigoSituacao, DbType.Int32));

                if (registroExecucaoCurva.CodigoTipoEventoNotificacao != 0)
                {
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_EVEN_NOT", registroExecucaoCurva.CodigoTipoEventoNotificacao, DbType.Int32));
                }
                else
                {
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_EVEN_NOT", DBNull.Value, DbType.Int32));
                }

                if (registroExecucaoCurva.DataHoraLiberacaoCurva != DateTime.MinValue)
                {
                    data.ParameterIn.Add(new ParameterInWrapper("@DAT_HOR_LIBE_CURV", registroExecucaoCurva.DataHoraLiberacaoCurva, DbType.DateTime));
                }
                else
                {
                    data.ParameterIn.Add(new ParameterInWrapper("@DAT_HOR_LIBE_CURV", DBNull.Value, DbType.DateTime));
                }

                data.ExecuteNonQuery("DB2IM.IMSKI");
                data.ParameterIn.Clear();


                foreach (CurvaExecucaoPonto ponto in registroExecucaoCurva.CurvaExecucaoPonto)
                {
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", registroExecucaoCurva.CodigoCurva, DbType.Int32));
                    data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", ponto.DataInclusaoVigencia, DbType.DateTime));
                    data.ParameterIn.Add(new ParameterInWrapper("@DAT_HOR_EXEO_CURV", ponto.DataHoraExecucaoCurva, DbType.DateTime));
                    data.ParameterIn.Add(new ParameterInWrapper("@DAT_VCTO", ponto.DataVencimento, DbType.Date));

                    if (double.IsInfinity(ponto.ValorVertice) || double.IsNaN(ponto.ValorVertice))
                    {
                        data.ParameterIn.Add(new ParameterInWrapper("@VLR_PONT", -1, DbType.Double));
                    }
                    else
                    {
                        data.ParameterIn.Add(new ParameterInWrapper("@VLR_PONT", ponto.ValorVertice, DbType.Double));
                    }

                    data.ParameterIn.Add(new ParameterInWrapper("@QTD_DIA_CRRI", ponto.QuantidadeDiasCorridos, DbType.Int32));
                    data.ParameterIn.Add(new ParameterInWrapper("@QTD_DIA_UTIL", ponto.QuantidadeDiasUteis, DbType.Int32));
                    data.ParameterIn.Add(new ParameterInWrapper("@IND_VRTE", ponto.IndicadorVertice, DbType.Int16));

                    data.ExecuteNonQuery("DB2IM.IMSKJ");
                    data.ParameterIn.Clear();
                    data.ParameterOut.Clear();
                }

                data.CommitTransaction();

                return 1;
            }
            catch (DadosException ex)
            {
                data.RollBackTransaction();
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
                return 0;
            }
            catch (Exception ex)
            {
                data.RollBackTransaction();
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
                return 0;
            }
            finally
            {
                data.Dispose();
                data = null;
            }
        }

        public void CriarCurva(Curva curva)
        {
            IDataAccessWrapper data = null;

            data = EnterpriseLibraryFactory.GetDataAccess();

            try
            {
                data.BeginTransaction();

                curva.CurvaVigente.DataInclusao = System.DateTime.Now;

                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CURV", DbType.Int32, 4));
                data.ParameterIn.Add(new ParameterInWrapper("@DAT_ULTI_ALTE", curva.DataUltimaAlteracao, DbType.DateTime));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_MESA_OPER_TES", curva.CodigoMesaOperacaoTesouraria, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CATE_MERC", curva.CodigoCategoriaMercado, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_MODA_CURV", curva.CodigoModalidadeCurva, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_SITU", curva.CodigoSituacao, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_SUB_MESA_OPER", curva.CodigoSubMesaOperacao, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_CURV", curva.CodigoTipoCurva, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@DES_CURV", curva.DescricaoCurva, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@IND_LIBE_AUTA", Convert.ToInt16(curva.IndicadorLiberacaoAutomatica), DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@IND_PMTE_VERS", Convert.ToInt16(curva.IndicadorPermiteVersao), DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@IND_TRCI_CURV", Convert.ToInt16(curva.IndicadorTerceiraCurva), DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@NOM_CURV", curva.NomeCurva, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@NOM_INRN_CURV", curva.NomeInternoCurva, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@QTD_ANO_EXTE", curva.QuantidadeAnoExtensao, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_CURV_PAD", curva.CodigoTipoCurvaPadrao, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CLAF_CURV", curva.CodigoClassificacao, DbType.Int16));

                data.ExecuteNonQuery("DB2IM.IMSFF");
                curva.CodigoCurva = (int)data.ParameterOut[0].ParameterValue;
                data.ParameterIn.Clear();
                data.ParameterOut.Clear();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", curva.CurvaVigente.DataInclusao, DbType.DateTime));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_MODE_CALC", curva.CurvaVigente.CodigoModeloCalculo, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_ENTR_DAD", curva.CurvaVigente.CodigoTipoEntradaDado, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_PRZ", curva.CurvaVigente.CodigoTipoPrazo, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_PRZ_ENTR", curva.CurvaVigente.CodigoTipoPrazoEntrada, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_MOED", curva.CurvaVigente.CodigoMoeda, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_TXA", curva.CurvaVigente.CodigoTipoTaxa, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@DAT_INIO_CURV_VIG", curva.CurvaVigente.DataInicioVigencia, DbType.DateTime));
                data.ParameterIn.Add(new ParameterInWrapper("@DAT_FIM_CURV_VIGE", curva.CurvaVigente.DataFimVigencia, DbType.DateTime));
                data.ParameterIn.Add(new ParameterInWrapper("@IND_PMRO_FATR_1", Convert.ToInt16(curva.CurvaVigente.IndicadorPrimeiroFator1), DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_MODE_INTV_TOL", curva.CurvaVigente.CodigoModeloIntervaloTolerancia, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV_BASE_PMT", curva.CurvaVigente.CodigoCurvaBasePMT, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@IND_PMRO_LIBR_DFL", curva.CurvaVigente.IndicadorPrimeiraDefault, DbType.Int16));

                data.ExecuteNonQuery("DB2IM.IMSFN");
                data.ParameterIn.Clear();

                if (curva.GradeExecucaoCurva != null &&
                    curva.GradeExecucaoCurva.registroGradeExecucaoCurva != null &&
                    curva.GradeExecucaoCurva.registroGradeExecucaoCurva.Count > 0 &&
                    curva.GradeExecucaoCurva.CodigoTipoExecucaoCurva != 2)
                {
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_EXEO_GRD", curva.GradeExecucaoCurva.CodigoTipoExecucaoCurva, DbType.Int16));
                    data.ParameterIn.Add(new ParameterInWrapper("@HOR_INIO", curva.GradeExecucaoCurva.HoraInicio.TimeOfDay, DbType.Time));
                    data.ParameterIn.Add(new ParameterInWrapper("@HOR_FIM", curva.GradeExecucaoCurva.HoraFim.TimeOfDay, DbType.Time));
                    data.ParameterIn.Add(new ParameterInWrapper("@QTD_TEMP", curva.GradeExecucaoCurva.QuantidadeTempo, DbType.Int16));
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_UNID_TEMP", curva.GradeExecucaoCurva.CodigoUnidadeTempo, DbType.Int16));

                    data.ExecuteNonQuery("DB2IM.IMSEX");
                    data.ParameterIn.Clear();

                    if (curva.GradeExecucaoCurva.registroGradeExecucaoCurva != null &&
                        curva.GradeExecucaoCurva.registroGradeExecucaoCurva.Count > 0)
                    {
                        foreach (RegistroGradeExecucaoCurva registroGrade in curva.GradeExecucaoCurva.registroGradeExecucaoCurva)
                        {
                            data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                            data.ParameterIn.Add(new ParameterInWrapper("@NUM_EXEO", registroGrade.NumeroExecucao, DbType.Int16));
                            data.ParameterIn.Add(new ParameterInWrapper("@HOR_EXEO", registroGrade.HoraExecucao.TimeOfDay, DbType.Time));

                            data.ExecuteNonQuery("DB2IM.IMSEY");
                            data.ParameterIn.Clear();
                        }
                    }

                }

                if (curva.CurvaVigente != null)
                {
                    if (curva.TipoEntradaDado == 3 && curva.CurvaVigente.ImportacaoArquivo != null && curva.CurvaVigente.ImportacaoArquivo.NomeArquivo != null)
                    {
                        data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                        data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", curva.CurvaVigente.DataInclusao, DbType.DateTime));
                        data.ParameterIn.Add(new ParameterInWrapper("@SIG_TIPO_ARQU", curva.CurvaVigente.ImportacaoArquivo.Sigla, DbType.String));
                        data.ParameterIn.Add(new ParameterInWrapper("@NOM_DRTO", curva.CurvaVigente.ImportacaoArquivo.Diretorio, DbType.String));
                        data.ParameterIn.Add(new ParameterInWrapper("@NOM_ARQU", curva.CurvaVigente.ImportacaoArquivo.NomeArquivo, DbType.String));
                        data.ParameterIn.Add(new ParameterInWrapper("@NOM_PNLH", curva.CurvaVigente.ImportacaoArquivo.NomePlanilha, DbType.String));
                        data.ParameterIn.Add(new ParameterInWrapper("@IND_VLDO_DAT_RFRC", curva.CurvaVigente.ImportacaoArquivo.IndicadorValidacaoData ? "S" : "N", DbType.String));
                        data.ParameterIn.Add(new ParameterInWrapper("@IND_VLDO_NOM_ARQU", curva.CurvaVigente.ImportacaoArquivo.IndicadorValidacaoArquivo ? "S" : "N", DbType.String));

                        data.ExecuteNonQuery("DB2IM.IM0SPA");
                        data.ParameterIn.Clear();
                    }

                    if (curva.TipoEntradaDado == 1
                        && curva.CurvaVigente.ComposicaoCurva != null
                        && !string.IsNullOrEmpty(curva.CurvaVigente.ComposicaoCurva.FormulaComposicao))
                    {
                        data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                        data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", curva.CurvaVigente.DataInclusao, DbType.DateTime));
                        data.ParameterIn.Add(new ParameterInWrapper("@DES_FORU_CPSC", curva.CurvaVigente.ComposicaoCurva.FormulaComposicao, DbType.String));

                        data.ExecuteNonQuery("DB2IM.IMS47");
                        data.ParameterIn.Clear();

                        if (curva.CurvaVigente.ComposicaoCurva.Itens != null
                            && curva.CurvaVigente.ComposicaoCurva.Itens.Count > 0)
                        {
                            foreach (ItemComposicao itemComposicao in curva.CurvaVigente.ComposicaoCurva.Itens)
                            {
                                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                                data.ParameterIn.Add(new ParameterInWrapper("@COD_OPRO_FORU_CPS", itemComposicao.OperandoFormula, DbType.String));
                                data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", curva.CurvaVigente.DataInclusao, DbType.DateTime));
                                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_CPSC", itemComposicao.CodigoTipoComposicao, DbType.Int16));
                                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV_ITGT", itemComposicao.CodigoCurvaIntegrante, DbType.Int32));
                                data.ParameterIn.Add(new ParameterInWrapper("@COD_COTC_SRIE_ITG", itemComposicao.CodigoSerieIntegrante, DbType.Int32));
                                data.ParameterIn.Add(new ParameterInWrapper("@IND_CURV_BASE", itemComposicao.IndicadorCurvaBase, DbType.Int16));
                                data.ParameterIn.Add(new ParameterInWrapper("@COD_FAMI", itemComposicao.CodigoFamilia, DbType.Int32));
                                data.ParameterIn.Add(new ParameterInWrapper("@COD_SRIE", itemComposicao.CodigoSerie, DbType.Int32));
                                data.ParameterIn.Add(new ParameterInWrapper("@COD_ATBT", itemComposicao.CodigoAtributo, DbType.Int32));
                                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_ATBT", itemComposicao.CodigoTipoAtributo, DbType.Int16));

                                data.ExecuteNonQuery("DB2IM.IMSIY");
                                data.ParameterIn.Clear();
                            }
                        }
                    }

                    if (curva.CurvaVigente.lstTaxaPontoCurvaVigente != null
                        && curva.CurvaVigente.lstTaxaPontoCurvaVigente.Count > 0)
                    {
                        foreach (TaxaPontoCurvaVigente taxaPontoCurvaVigente in curva.CurvaVigente.lstTaxaPontoCurvaVigente)
                        {
                            data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                            data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_PONT_CUR", taxaPontoCurvaVigente.CodigoTipoPontoCurva, DbType.Int16));
                            data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_TXA", taxaPontoCurvaVigente.CodigoTipoTaxa, DbType.Int16));
                            data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", curva.CurvaVigente.DataInclusao, DbType.DateTime));

                            data.ExecuteNonQuery("DB2IM.IMSHR");
                            data.ParameterIn.Clear();
                        }
                    }

                    if (curva.CurvaSucessora != null && curva.CurvaSucessora.CodigoCurva != 0)
                    {
                        data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                        data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", curva.CurvaVigente.DataInclusao, DbType.DateTime));
                        data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV_SUCE", curva.CurvaSucessora.CodigoCurva, DbType.Int32));

                        data.ExecuteNonQuery("DB2IM.IMSFJ");
                        data.ParameterIn.Clear();
                    }
                }

                data.CommitTransaction();
            }
            catch (DadosException ex)
            {
                data.RollBackTransaction();
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                data.RollBackTransaction();
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                curva = null;
                data.Dispose();
                data = null;
            }
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método retornar a consulta.                                                     <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>objeto "ModeloIntervaloTolerancia".</returns>
        public ModeloIntervaloTolerancia ObterIntervaloTolerancia(int modeloIntervaloID)
        {
            //Declara e instancia o objeto
            ModeloIntervaloTolerancia objIntervaloTolerancia;
            IDataAccessWrapper data = null;
            DataSet ds;

            try
            {
                //Instancia o objeto
                objIntervaloTolerancia = new ModeloIntervaloTolerancia();

                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Adiciona Parametro de entrada
                data.ParameterIn.Add(new ParameterInWrapper("@COD_MODE_INTV_TOL", modeloIntervaloID, DbType.Int32));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_INTV_TOL", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_ACAO_RETE", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_MODE_INTV_TOL", DbType.String, 30));
                data.ParameterOut.Add(new ParameterOutWrapper("@DES_MODE_INTV_TOL", DbType.String, 100));


                //Recupera a consulta
                ds = data.ExecuteParameterToDataSet("DB2IM.IMS08");
                data.ParameterIn.Clear();
                data.ParameterOut.Clear();

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Monta o objeto
                    objIntervaloTolerancia = EntidadeFactory.getModeloIntervaloToleranciaParametro(ds.Tables[0].Rows[0]);
                    objIntervaloTolerancia.lstParametroModeloIntervaloTolerancia = new List<ParametroModeloIntervaloTolerancia>();

                    //Adiciona Parametro de entrada
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_MODE_INTV_TOL", modeloIntervaloID, DbType.Int32));

                    //Recupera a consulta                    
                    ds = data.ExecuteDataSet("DB2IM.IMS07");
                    data.ParameterIn.Clear();

                    if (ds != null && ds.Tables.Count > 0)
                    {
                        //Percorre todos os registros da tabela
                        foreach (DataRow linha in ds.Tables[0].Rows)
                        {
                            //Monta e adiciona o objeto na lista
                            objIntervaloTolerancia.lstParametroModeloIntervaloTolerancia.Add(EntidadeFactory.getParametroModeloIntervaloTolerancia(linha));
                        }
                    }
                }

                //retorna a consulta
                return objIntervaloTolerancia;

            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Finaliza os objetos
                data.Dispose();
                data = null;
                ds = null;
                objIntervaloTolerancia = null;
            }

            //Retorna a consulta vazia
            return new ModeloIntervaloTolerancia();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método retornar a consulta.                                                     <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>objeto "CurvaVigente".</returns>
        public CurvaVigente ObterCurvaVigente(int curvaID)
        {
            //Declara e instancia o objeto
            CurvaVigente objCurvaVigente = new CurvaVigente();
            IDataAccessWrapper data = null;
            DataSet ds = null;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Adiciona Parametro de entrada
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));
                data.ParameterOut.Add(new ParameterOutWrapper("@DAT_INCU_VIGE", DbType.DateTime, 26));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MODE_CALC", DbType.Int16, 4));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_ENTR_DADO", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_PRZ", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_PRZ_ENTR", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MOED", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_TXA", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MODE_INTV_TOLE", DbType.Int32, 4));
                data.ParameterOut.Add(new ParameterOutWrapper("@DAT_INIO_CURV_VIGE", DbType.DateTime, 26));
                data.ParameterOut.Add(new ParameterOutWrapper("@DAT_FIM_CURV_VIGE", DbType.DateTime, 26));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_PMRO_FATR_1", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CURV_BASE_PMT", DbType.Int32, 4));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_PMRO_LIBR_DFL", DbType.Int16, 2));

                //Recupera a consulta
                ds = data.ExecuteParameterToDataSet("DB2IM.IMS10");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Monta o objeto
                    objCurvaVigente = EntidadeFactory.getCurvaVigente(ds.Tables[0].Rows[0]);
                }

                //Retorna a consulta
                return objCurvaVigente;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Finaliza os objetos
                data.Dispose();
                data = null;
                objCurvaVigente = null;
                ds = null;
            }

            //Retorna a consulta vazia
            return new CurvaVigente();
        }

        public CurvaVigente ObterCurvaVigentePorDataReferencia(int curvaID, DateTime dataReferencia)
        {
            //Declara e instancia o objeto
            CurvaVigente objCurvaVigente;
            List<TaxaPontoCurvaVigente> listaTaxaPontoCurvaVigente;
            IDataAccessWrapper data = null;
            DataSet ds = null;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Instancia CurvaVigente
                objCurvaVigente = new CurvaVigente();

                //Adiciona Parametro de entrada
                data.ParameterIn.Add(new ParameterInWrapper("@DAT_CURV_VIGE", dataReferencia, DbType.DateTime));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));
                data.ParameterOut.Add(new ParameterOutWrapper("@DAT_INCU_VIGE", DbType.DateTime, 26));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MODE_CALC", DbType.Int16, 4));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_ENTR_DADO", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_PRZ", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_PRZ_ENTR", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MOED", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_TXA", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MODE_INTV_TOLE", DbType.Int32, 4));
                data.ParameterOut.Add(new ParameterOutWrapper("@DAT_INIO_CURV_VIGE", DbType.DateTime, 26));
                data.ParameterOut.Add(new ParameterOutWrapper("@DAT_FIM_CURV_VIGE", DbType.DateTime, 26));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_PMRO_FATR_1", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CURV_BASE_PMT", DbType.Int32, 4));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_PMRO_LIBR_DFL", DbType.Int16, 2));

                //Recupera a consulta
                ds = data.ExecuteParameterToDataSet("DB2IM.IMS2D");

                //Limpa Lista de Parametros
                data.ParameterIn.Clear();
                data.ParameterOut.Clear();

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Monta o objeto
                    objCurvaVigente = EntidadeFactory.getCurvaVigente(ds.Tables[0].Rows[0]);

                    data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));
                    data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", objCurvaVigente.DataInclusao, DbType.DateTime));

                    //Recupera a consulta
                    ds = data.ExecuteDataSet("DB2IM.IMSEK");

                    if (ds != null && ds.Tables.Count > 0)
                    {
                        //Instancia a lista
                        listaTaxaPontoCurvaVigente = new List<TaxaPontoCurvaVigente>();

                        //Percorre todos os registros da tabela
                        foreach (DataRow linha in ds.Tables[0].Rows)
                        {
                            //Adiciona os valores no objeto
                            listaTaxaPontoCurvaVigente.Add(EntidadeFactory.getTaxaPontoCurvaVigente(linha));
                        }

                        //Configura o retorno
                        objCurvaVigente.lstTaxaPontoCurvaVigente = listaTaxaPontoCurvaVigente;
                    }
                }

                //Retorna a consulta
                return objCurvaVigente;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Finaliza os objetos
                data.Dispose();
                data = null;
                objCurvaVigente = null;
                listaTaxaPontoCurvaVigente = null;
                ds = null;
            }

            //Retorna a consulta vazia
            return new CurvaVigente();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 11/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método ObterTiposAcaoRetencaoCurva.                                             <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "TipoAcaoRetencaoCurva".</returns>
        public IList<TipoAcaoRetencaoCurva> ObterTiposAcaoRetencaoCurva()
        {
            //Cria a TipoAcaoRetencaoCurva
            List<TipoAcaoRetencaoCurva> listTipoAcaoRetencaoCurva = new List<TipoAcaoRetencaoCurva>();

            //Declara o objeto
            IDataAccessWrapper data = null;

            try
            {
                //Instancia o objeto
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Executa a Procedure
                DataSet ds = data.ExecuteDataSet("DB2IM.IMS05");

                //Verifica se o Dataset retornado está vazio
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre o Dataset
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Adiciona a Unidade na lista
                        listTipoAcaoRetencaoCurva.Add(EntidadeFactory.getTipoAcaoRetencaoCurva(linha));
                    }
                }
                //Retorna a lista de Unidades
                return listTipoAcaoRetencaoCurva;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Desaloca os objetos
                listTipoAcaoRetencaoCurva = null;
                data.Dispose();
                data = null;
            }
            //Retorna a consulta limpa
            return new List<TipoAcaoRetencaoCurva>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 17/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método ObterItensComposicao.                                                    <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <param name="CurvaCompostaID">CurvaCompostaID</param>
        /// <param name="dataInclusaoVigencia">dataInclusaoVigencia</param>
        /// <returns>Lista de objetos "ItemComposicao".</returns>
        public IList<ItemComposicao> ObterItensComposicao(int curvaCompostaID, DateTime dataInclusaoVigencia)
        {
            //Cria a lista ItemComposicao
            List<ItemComposicao> listItemComposicao = new List<ItemComposicao>();

            //Declara o objeto
            IDataAccessWrapper data = null;

            try
            {
                //Instancia o objeto
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaCompostaID, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", dataInclusaoVigencia, DbType.DateTime));

                //Executa a Procedure
                DataSet ds = data.ExecuteDataSet("DB2IM.IMSET");

                //Verifica se o Dataset retornado está vazio
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre o Dataset
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Adiciona a Unidade na lista
                        listItemComposicao.Add(EntidadeFactory.getItemComposicao(linha));
                    }
                }
                //Retorna a lista de Unidades
                return listItemComposicao;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Desaloca os objetos
                listItemComposicao = null;
                data.Dispose();
                data = null;
            }
            //Retorna a consulta limpa
            return new List<ItemComposicao>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 12/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Obter Curvas Vigente Por Tipo Mesa Origem Categoria                             <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <param name="mesaID">mesaID</param>
        /// <param name="tipoCurvaID">tipoCurvaID</param>
        /// <param name="categoriaID">categoriaID</param>
        /// <returns>Lista de CurvaVigente</returns>
        public IList<CurvaVigente> ObterCurvasVigentePorTipoMesaOrigemCategoria(int mesaID, int tipoCurvaID, int categoriaID, int codigoSituacaoAtiva, int codigoSituacaoPendente)
        {
            //Declara os objetos
            List<CurvaVigente> lista;
            IDataAccessWrapper data = null;
            DataSet ds;

            try
            {
                // Instância o objeto
                lista = new List<CurvaVigente>();

                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                // Adiciona Parâmetro de entrada no objeto data.
                data.ParameterIn.Add(new ParameterInWrapper("@COD_MESA_OPER_TES", mesaID, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CATE_MERC", categoriaID, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_CURV", tipoCurvaID, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_SITU1", codigoSituacaoAtiva, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_SITU2", codigoSituacaoPendente, DbType.Int16));

                //Recupera a consulta
                ds = data.ExecuteDataSet("DB2IM.IMS09");

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        lista.Add(EntidadeFactory.getCurvaVigente(linha));
                    }
                }
                //Retorna a consulta
                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                lista = null;
                data.Dispose();
                data = null;
                ds = null;
            }

            //Retorna a consulta vazia
            return new List<CurvaVigente>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 12/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método "ObterCurvasVigentePorTipoMesaOrigemCategoriaTipoEntrada".               <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <param name="codigoSubmesa">codigoSubmesa</param>
        /// <param name="codigoTipoCurva">codigoTipoCurva</param>
        /// <param name="codigoCategoriaMercado">codigoCategoriaMercado</param>
        /// <param name="codigoSituacaoAtiva">codigoSituacaoAtiva</param>
        /// <param name="codigoSituacaoPendente">codigoSituacaoPendente</param>
        /// <param name="codigoTipoEntradaDado">codigoTipoEntradaDado</param>
        /// <returns>Lista de Curva</returns>
        public IList<Curva> ObterCurvasVigentePorTipoMesaOrigemCategoriaTipoEntrada(int codigoSubmesa, int codigoTipoCurva,
            int codigoCategoriaMercado, int codigoSituacaoAtiva, int codigoSituacaoPendente, int codigoTipoEntradaDado)
        {
            //Cria a lista ItemComposicao
            List<Curva> lista = new List<Curva>();

            //Declara o objeto
            IDataAccessWrapper data = null;

            try
            {
                //Instancia o objeto
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_MESA_OPER_TES", codigoSubmesa, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CATE_MERC", codigoCategoriaMercado, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_CURV", codigoTipoCurva, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_SITU1", codigoSituacaoAtiva, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_SITU2", codigoSituacaoPendente, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_ENTR_DAD", codigoTipoEntradaDado, DbType.Int32));

                //Recupera a consulta
                //ds = data.ExecuteDataSet("DB2IM.IMS06");
                DataSet ds = data.ExecuteDataSet("DB2IM.IMS06");

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        lista.Add(EntidadeFactory.getCurvaObterCurvasVigentePorTipoMesaOrigemCategoriaTipoEntrada(linha));
                    }
                }
                //Retorna a consulta
                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                lista = null;
                data.Dispose();
                data = null;
                //ds = null;
            }

            //Retorna a consulta vazia
            return new List<Curva>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 08/09/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método ObterCurvasRetidasPorTipoMesaCategoriaSituacao.                          <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <param name="tipoCurvaID">tipoCurvaID</param>
        /// <param name="subMesaID">subMesaID</param>
        /// <param name="categoriaMercadoID">categoriaMercadoID</param>
        /// <param name="codigoSituacao">codigoSituacao</param>
        /// <returns>Lista de objetos "Curva".</returns>
        public IList<Curva> ObterCurvasRetidasPorTipoMesaCategoriaSituacao(int tipoCurvaID, int subMesaID, int categoriaMercadoID, int codigoSituacao)
        {
            //Cria a lista ItemComposicao
            List<Curva> listCurva = new List<Curva>();

            //Cria o objeto Curva 
            Curva objCurvaRetorno = null;

            //Declara o objeto
            IDataAccessWrapper data = null;

            try
            {
                //Instancia o objeto
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Adiciona o parâmetro tipoCurvaID
                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_CURV", tipoCurvaID, DbType.Int32));

                //Adiciona o parâmetro subMesaID
                data.ParameterIn.Add(new ParameterInWrapper("@COD_SUB_MESA_OPER", subMesaID, DbType.Int32));

                //Adiciona o parâmetro categoriaMercadoID
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CATE_MERC", categoriaMercadoID, DbType.Int32));

                //Adiciona o parâmetro codigoSituacao
                data.ParameterIn.Add(new ParameterInWrapper("@COD_SITU", codigoSituacao, DbType.Int32));

                //Executa a Procedure
                DataSet ds = data.ExecuteDataSet("DB2IM.IMS62");

                //Verifica se o Dataset retornado está vazio
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre o Dataset
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Obtem a Curva acessando a PROC
                        objCurvaRetorno = EntidadeFactory.getCurvaIMS62(linha);

                        //Adiciona o parametro codigoSituacao que veio da entrada para todos os objetos RegistroExecucaoCurva
                        foreach (RegistroExecucaoCurva item in objCurvaRetorno.CurvaVigente.RegistroExecucaoCurva)
                        {
                            item.CodigoSituacao = codigoSituacao;
                        }

                        //Adiciona a Curva na lista
                        listCurva.Add(objCurvaRetorno);
                    }
                }
                //Retorna a lista de Unidades
                return listCurva;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Desaloca os objetos
                listCurva = null;
                data.Dispose();
                data = null;
                objCurvaRetorno = null;
            }
            //Retorna a consulta limpa
            return new List<Curva>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 12/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Obter Curvas Compostas Vigentes Pelo Fator                                      <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <param name="codigoCurvaComponente">codigoCurvaComponente</param>
        /// <returns>Lista de CurvaVigente</returns>
        public IList<CurvaVigente> ObterCurvasCompostasVigentesPeloFator(int codigoCurvaComponente)
        {
            //Declara os objetos
            List<CurvaVigente> lista;
            IDataAccessWrapper data = null;
            DataSet ds;

            try
            {
                // Instância o objeto
                lista = new List<CurvaVigente>();

                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV_ITGT", codigoCurvaComponente, DbType.Int32));

                //Recupera a consulta
                ds = data.ExecuteDataSet("DB2IM.IMSEJ");

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        lista.Add(EntidadeFactory.getCurvaVigente(linha));
                    }
                }
                //Retorna a consulta
                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                lista = null;
                data.Dispose();
                data = null;
                ds = null;
            }

            //Retorna a consulta vazia
            return new List<CurvaVigente>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 09/09/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Obter Intervalos Tolerancia                                                     <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de ModeloIntervaloTolerancia</returns>
        public IList<ModeloIntervaloTolerancia> ObterIntervalosTolerancia()
        {
            //Declara e instancia o objeto
            List<ModeloIntervaloTolerancia> lista = new List<ModeloIntervaloTolerancia>();
            IDataAccessWrapper data = null;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Recupera a consulta
                DataSet ds = data.ExecuteDataSet("DB2IM.IMS04");

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        lista.Add(EntidadeFactory.getModeloIntervaloTolerancia(linha));
                    }
                }

                //Retorna a consulta
                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Finaliza os objetos
                lista = null;
                data.Dispose();
                data = null;
            }

            //Retorna
            return new List<ModeloIntervaloTolerancia>();

        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 09/09/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Obter Dados Arquivo Importacao                                                  <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Objeto "ImportacaoArquivo"</returns>
        /// <param name="codigoCurva">codigoCurva</param>
        /// <param name="dataInclusaoVigencia">dataInclusaoVigencia</param>
        public ImportacaoArquivo ObterDadosArquivoImportacao(int codigoCurva, DateTime dataInclusaoVigencia)
        {
            //Declara os objetos
            ImportacaoArquivo objImportacaoArquivo;
            DataSet ds;
            IDataAccessWrapper data = null;

            try
            {
                objImportacaoArquivo = new ImportacaoArquivo();

                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Parametro de Entrada 
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", codigoCurva, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", dataInclusaoVigencia, DbType.DateTime));
                data.ParameterOut.Add(new ParameterOutWrapper("@SIG_TIPO_ARQU", DbType.String, 4));
                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_DRTO", DbType.String, 100));
                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_ARQU", DbType.String, 30));
                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_PNLH", DbType.String, 30));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_VLDO_DAT_RFRC", DbType.String, 1));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_VLDO_NOM_ARQU", DbType.String, 1));

                //Recupera a consulta
                ds = data.ExecuteParameterToDataSet("DB2IM.IM0SPB");

                //Limpa Lista de Parametros
                data.ParameterIn.Clear();

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Monta o objeto
                        objImportacaoArquivo = EntidadeFactory.getImportacaoArquivo(linha);
                    }
                }

                //Retorna a consulta
                return objImportacaoArquivo;

            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }

            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }

            finally
            {
                //Desaloca o objeto
                data.Dispose();
                data = null;
                objImportacaoArquivo = null;
                ds = null;
            }

            return new ImportacaoArquivo();


        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 10/09/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Atualizar Curva Vigente                                                       <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <param name="curvaVigente">curvaVigente</param>
        public void AtualizarCurvaVigente(CurvaVigente curvaVigente)
        {
            IDataAccessWrapper data = null;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                // Verifica se é válido
                if (curvaVigente != null)
                {
                    //Atualiza o valor
                    curvaVigente.DataFimVigencia = DateTime.Now;

                    //Adiciona os parâmetros antes de executar a procedure
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaVigente.CodigoCurvaVigente, DbType.Int32));
                    data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", curvaVigente.DataInclusao, DbType.DateTime));
                    data.ParameterIn.Add(new ParameterInWrapper("@DAT_FIM_CURV_VIGE", curvaVigente.DataFimVigencia, DbType.DateTime));

                    data.ExecuteNonQuery("DB2IM.IMSFP");
                    data.ParameterIn.Clear();
                }

                // Verifica se é válido
                if (curvaVigente != null)
                {
                    //Atualiza o valor
                    curvaVigente.DataInicioVigencia = curvaVigente.DataFimVigencia.AddMilliseconds(1);
                    curvaVigente.DataInclusao = curvaVigente.DataInicioVigencia.AddDays(1);

                    //Adiciona os parâmetros antes de executar a procedure
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaVigente.CodigoCurvaVigente, DbType.Int32));
                    data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", curvaVigente.DataInclusao, DbType.DateTime));
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_MODE_CALC", curvaVigente.CodigoModeloCalculo, DbType.Int32));
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_ENTR_DAD", curvaVigente.CodigoTipoEntradaDado, DbType.Int16));
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_PRZ", curvaVigente.CodigoTipoPrazo, DbType.Int16));
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_PRZ_ENTR", curvaVigente.CodigoTipoPrazoEntrada, DbType.Int16));
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_MOED", curvaVigente.CodigoMoeda, DbType.Int16));
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_TXA", curvaVigente.CodigoTipoTaxa, DbType.Int16));
                    data.ParameterIn.Add(new ParameterInWrapper("@DAT_INIO_CURV_VIG", curvaVigente.DataInicioVigencia, DbType.DateTime));
                    data.ParameterIn.Add(new ParameterInWrapper("@DAT_FIM_CURV_VIGE", DBNull.Value, DbType.DateTime));
                    data.ParameterIn.Add(new ParameterInWrapper("@IND_PMRO_FATR_1", Convert.ToInt32(curvaVigente.IndicadorPrimeiroFator1), DbType.Int16));
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_MODE_INTV_TOL", curvaVigente.CodigoModeloIntervaloTolerancia, DbType.Int32));
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV_BASE_PMT", curvaVigente.CodigoCurvaBasePMT, DbType.Int32));
                    data.ParameterIn.Add(new ParameterInWrapper("@IND_PMRO_LIBR_DFL", false, DbType.Int16));

                    data.ExecuteNonQuery("DB2IM.IMSFN");
                }
            }

            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }

            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }

            finally
            {
                data.Dispose();
                data = null;
            }
        }

        public void EncerrarVigenciaCurvaDefault(DateTime dataFim)
        {
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();
                data.ParameterIn.Add(new ParameterInWrapper("@DAT_FIM_VIGE_DFLT", dataFim, DbType.DateTime));
                data.ExecuteNonQuery("DB2IM.IMS1X");
            }

            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }

            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }

            finally
            {
                data.Dispose();
                data = null;
            }
        }

        public void CriarCurvaDefault(int codigoCurvaDefault, DateTime dataInicio)
        {
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", codigoCurvaDefault, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@DAT_INIO_VIGE_DFL", dataInicio, DbType.DateTime));
                data.ExecuteNonQuery("DB2IM.IMS1W");
            }

            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 11/11/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método retornar a consulta.                                                     <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>objeto "ComposicaoCurva".</returns>
        public ComposicaoCurva ObterCurvaComposicaoVigente(int codigoCurva, DateTime dataInclusaoVigencia)
        {
            //Declara e instancia o objeto
            ComposicaoCurva objIntervaloTolerancia;
            IDataAccessWrapper data = null;
            DataSet ds = null;

            try
            {
                //Instancia o objeto
                objIntervaloTolerancia = new ComposicaoCurva();

                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Adiciona Parametro de entrada
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", codigoCurva, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", dataInclusaoVigencia, DbType.DateTime));
                data.ParameterOut.Add(new ParameterOutWrapper("@DES_FORU_CPSC", DbType.String, 100));

                //Executa a procedure IMSFN
                ds = data.ExecuteParameterToDataSet("DB2IM.IMS73");
                //Limpa Lista de Parametros
                data.ParameterIn.Clear();

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Monta o objeto
                    objIntervaloTolerancia = EntidadeFactory.getComposicaoCurva(ds.Tables[0].Rows[0]);

                }
                //retorna a consulta
                return objIntervaloTolerancia;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Finaliza os objetos
                data.Dispose();
                data = null;
                ds = null;
                objIntervaloTolerancia = null;
            }

            //Retorna a consulta vazia
            return new ComposicaoCurva();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 16/11/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método que retornar a consulta.                                                 <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "ModalidadeCurva".</returns>
        public IList<GradeExecucaoCurva> ObterGradesExecucaoCurvasAtivas()
        {
            //Declara o objeto
            IList<GradeExecucaoCurva> lista = new List<GradeExecucaoCurva>();
            IDataAccessWrapper data = null;
            DataSet ds;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Recupera a consulta
                ds = data.ExecuteDataSet("DB2IM.IMS72");

                //Verifica se é válido
                if (ds != null && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre os itens
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Adiciona o item
                        lista.Add(EntidadeFactory.getGradesExecucaoCurvasAtivas(linha));
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Finaliza os objetos
                data.Dispose();
                data = null;
                ds = null;
            }

            //Retorna a lista de objetos da consulta
            return lista;
        }

        public IList<RegistroGradeExecucaoCurva> ObterRegistrosGradeExecucaoCurva(int curvaID)
        {
            //Declara o objeto
            List<RegistroGradeExecucaoCurva> listaRegistroGradeExecucao;
            IDataAccessWrapper data = null;
            DataSet ds;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                listaRegistroGradeExecucao = new List<RegistroGradeExecucaoCurva>();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));

                //Recupera a consulta
                ds = data.ExecuteDataSet("DB2IM.IMSEW");

                //Limpa Lista de Parametros
                data.ParameterIn.Clear();
                data.ParameterOut.Clear();

                if (ds.Tables.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Recupera os itens
                        listaRegistroGradeExecucao.Add(EntidadeFactory.getRegistroGradeExecucaoCurva(linha));
                    }
                }

                return listaRegistroGradeExecucao;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Finaliza os objetos
                data.Dispose();
                data = null;
                ds = null;
                listaRegistroGradeExecucao = null;
            }

            return new List<RegistroGradeExecucaoCurva>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 16/11/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Obter Intervalos Tolerancia                                                     <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de ModeloIntervaloTolerancia</returns>
        public IList<RegistroGradeExecucaoCurva> ObterRegistrosGradeExecucaoCurvaPorCurvaERangeHorario(int codigoCurva, DateTime horaInicio, DateTime horaFim)
        {
            //Declara e instancia o objeto
            IList<RegistroGradeExecucaoCurva> lista = new List<RegistroGradeExecucaoCurva>();
            //Declara e instancia os objetos            
            IDataAccessWrapper data = null;

            try
            {
                // Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                // Configura os parâmetro de entrada.
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", codigoCurva, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@HOR_INIO", horaInicio.TimeOfDay, DbType.Time));
                data.ParameterIn.Add(new ParameterInWrapper("@HOR_FIM", horaFim.TimeOfDay, DbType.Time));

                // Recupera os resultados da consulta.
                DataSet ds = data.ExecuteDataSet("DB2IM.IMSO1");

                // Verifica se é válido o retorno
                if (ds != null && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        // Recupera o objeto e adiciona na lista de retorno.
                        lista.Add(EntidadeFactory.getObterRegistrosGradeExecucaoCurvaPorCurvaERangeHorario(linha));

                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Finaliza os objetos
                data.Dispose();
                data = null;
            }

            //Retorna
            return lista;

        }

        public Curva ObterCurvaPorNomeInterno(string nomeInterno)
        {
            //Declara e instancia o objeto
            Curva curva = new Curva();
            IDataAccessWrapper data = null;
            DataSet ds;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@NOM_INRN_CURV", nomeInterno, DbType.String));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CURV", DbType.Int32, 4));
                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_CURV", DbType.String, 80));
                data.ParameterOut.Add(new ParameterOutWrapper("@DES_CURV", DbType.String, 120));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MODA_CURV", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CATE_MERC", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_SITU", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_CURV", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_SUB_MESA_OPER", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MESA_OPER_TES", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@QTD_ANO_EXTE", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@DAT_ULTI_ALTE", DbType.DateTime, 26));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_LIBE_AUTA", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_PMTE_VERS", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_TRCI_CURV", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_CURV_PAD", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CLAF_CURV", DbType.Int16, 2));

                ds = data.ExecuteParameterToDataSet("DB2IM.IMSFK");

                data.ParameterIn.Clear();
                data.ParameterOut.Clear();

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    curva = EntidadeFactory.getObterCurva(ds.Tables[0].Rows[0]);
                }

                return curva;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                curva = null;
                data.Dispose();
                data = null;
                ds = null;
            }

            return curva;
        }

        public Curva ObterCurvaDefault()
        {
            Curva curva = new Curva();
            IDataAccessWrapper data = null;
            DataSet ds;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CURV", DbType.Int32, 4));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MODE_CALC", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MODE_INTV_TOL", DbType.Int32, 4));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MOED", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_ENTR_DAD", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_PRZ", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_PRZ_ENTR", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_TXA", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@DAT_FIM_CURV_VIGE", DbType.DateTime, 10));
                data.ParameterOut.Add(new ParameterOutWrapper("@DAT_INCU_VIGE", DbType.DateTime, 10));
                data.ParameterOut.Add(new ParameterOutWrapper("@DAT_INIO_CURV_VIG", DbType.DateTime, 10));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_PMRO_FATR_1", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CURV_BASE_PMT", DbType.Int32, 4));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_PMRO_LIBR_DFL", DbType.Int16, 2));

                ds = data.ExecuteParameterToDataSet("DB2IM.IMSO2");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    curva = EntidadeFactory.getObterCurvaDefault(ds.Tables[0].Rows[0]);
                }

                return curva;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                curva = null;
                data.Dispose();
                data = null;
                ds = null;
            }

            return curva;
        }

        public int ObterCodigoCurvaBase(int codigoCurvaComposta)
        {
            IDataAccessWrapper data = null;
            DataSet ds;
            int codigoCurvaBase = 0;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", codigoCurvaComposta, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@IND_CURV_BASE", 1, DbType.Int16));

                ds = data.ExecuteDataSet("DB2IM.IM0S6F");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    codigoCurvaBase = Convert.ToInt32(ds.Tables[0].Rows[0]["COD_CURV_ITGT"]);
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
                ds = null;
            }

            return codigoCurvaBase;
        }

        public IList<ParametroModeloIntervaloTolerancia> ObterParametrosModeloIntervaloTolerancia(int codigoModelo)
        {
            IList<ParametroModeloIntervaloTolerancia> lista = new List<ParametroModeloIntervaloTolerancia>();
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_MODE_INTV_TOL", codigoModelo, DbType.Int32));

                DataSet ds = data.ExecuteDataSet("DB2IM.IMS07");

                if (ds != null && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        lista.Add(EntidadeFactory.getObterParametrosModeloIntervaloTolerancia(linha));
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }

            return lista;
        }

        public IList<Curva> ObterCurvasLiberadasPorDataTipoModalidade(DateTime dataExecucao, int tipoCurva, int modalidade)
        {
            IList<Curva> lista = new List<Curva>();
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                DateTime dataExecucaoInicio = new DateTime(dataExecucao.Year, dataExecucao.Month, dataExecucao.Day, 0, 0, 0);
                DateTime dataExecucaoFinal = new DateTime(dataExecucao.Year, dataExecucao.Month, dataExecucao.Day, 23, 59, 59);

                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_CURV", tipoCurva, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_MODA_CURVA", modalidade, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@DAT_HORA_EXEO_INI", dataExecucaoInicio, DbType.DateTime));
                data.ParameterIn.Add(new ParameterInWrapper("@DAT_HORA_EXEO_FIM", dataExecucaoFinal, DbType.DateTime));

                DataSet ds = data.ExecuteDataSet("DB2IM.IMS1U");

                if (ds != null && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        Curva curva = new Curva();
                        lista.Add(EntidadeFactory.getObterCurvasLiberadasPorDataTipoModalidade(linha));
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }

            return lista;
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Matheus Khalil                                                                  <BR/>
        /// DATA DE CRIAÇÃO : 27/01/2011                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método que realiza a criação do modelo de tunelamento.                          <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <param name="modeloIntervaloTolerancia"></param>
        /// <returns></returns>
        public void CriarIntervaloTolerancia(ModeloIntervaloTolerancia modeloIntervaloTolerancia)
        {
            //Declara e instancia os objetos            
            IDataAccessWrapper data = null;
            int returnCode = 0;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.BeginTransaction();
                // Configura os parâmetro de entrada.
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MODE_INTV", DbType.Int32, 4));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_INTV", modeloIntervaloTolerancia.codigoTipoIntervaloTolerancia, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_ACAO_RETE", modeloIntervaloTolerancia.codigoacaoRetensao, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@NOM_MODE_INTV", modeloIntervaloTolerancia.nomeModeloIntervaloTolerancia, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@DES_MODE_INTV", modeloIntervaloTolerancia.descricaoModeloIntervaloTolerancia, DbType.String));

                // Recupera os resultados da consulta.
                DataSet dsModelo = data.ExecuteParameterToDataSet("DB2IM.IMSJX");

                data.ParameterIn.Clear();
                data.ParameterOut.Clear();

                int codigoModelo = 0;
                if (dsModelo.Tables.Count > 0)
                {
                    codigoModelo = (Int32)dsModelo.Tables[0].Rows[0][4];
                }

                //Incluir Pontos Intervalo de Tolerancia Tunelamento (proc. IMSJW)
                foreach (var item in modeloIntervaloTolerancia.lstParametroModeloIntervaloTolerancia)
                {
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_MODE_INTV_TO", codigoModelo, DbType.Int16));
                    data.ParameterIn.Add(new ParameterInWrapper("@PRZ_DIA_CURVE", item.PrazoDiaCurva, DbType.Int32));
                    data.ParameterIn.Add(new ParameterInWrapper("@VLR_TOLE_INFE", item.ValorToleranciaInferior, DbType.Decimal));
                    data.ParameterIn.Add(new ParameterInWrapper("@VLR_TOLE_SUPI", item.ValorToleranciaSuperior, DbType.Decimal));

                    returnCode = data.ExecuteNonQuery("DB2IM.IMSJW");
                    data.ParameterIn.Clear();
                    data.ParameterOut.Clear();
                }
                //Confirma a transação no banco de dados.
                data.CommitTransaction();

            }
            catch (DadosException ex)
            {
                //Retorna a transação no banco de dados.
                data.RollBackTransaction();
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                //Retorna a transação no banco de dados.
                data.RollBackTransaction();
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Finaliza os objetos
                data.Dispose();
                data = null;
            }
        }


        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Matheus Khalil                                                                  <BR/>
        /// DATA DE CRIAÇÃO : 27/01/2011                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método que realiza a atualização do cadastro do modelo de tunelamento.          <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <param name="modeloIntervaloTolerancia"></param>
        /// <returns></returns>
        public void AtualizarIntervaloTolerancia(ModeloIntervaloTolerancia modeloIntervaloTolerancia)
        {
            //Declara e instancia os objetos            
            IDataAccessWrapper data = null;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Inicia uma transação no banco de dados.
                data.BeginTransaction();

                // Configura os parâmetro de entrada.
                data.ParameterIn.Add(new ParameterInWrapper("@COD_MODE_INTV_TO", modeloIntervaloTolerancia.Codigo, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_INTV_TO", modeloIntervaloTolerancia.codigoTipoIntervaloTolerancia, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_ACAO_RETE", modeloIntervaloTolerancia.codigoacaoRetensao, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@NOM_MODE_INTV_TO", modeloIntervaloTolerancia.nomeModeloIntervaloTolerancia, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@DES_MODE_INTV_TO", modeloIntervaloTolerancia.descricaoModeloIntervaloTolerancia, DbType.String));

                // Recupera os resultados da consulta.
                int returnCode = data.ExecuteNonQuery("DB2IM.IMS2E");

                data.ParameterIn.Clear();
                data.ParameterOut.Clear();

                //Deletar pontos de execuçao tolerancia tunelamento (proc. IMSLP)
                data.ParameterIn.Add(new ParameterInWrapper("@WCOD_MODE_INTV_TO", modeloIntervaloTolerancia.Codigo, DbType.Int32));
                returnCode = data.ExecuteNonQuery("DB2IM.IMSLP");

                //Incluir Pontos Intervalo de Tolerancia Tunelamento (proc. IMSJW)
                foreach (var item in modeloIntervaloTolerancia.lstParametroModeloIntervaloTolerancia)
                {
                    data.ParameterIn.Clear();
                    data.ParameterOut.Clear();

                    data.ParameterIn.Add(new ParameterInWrapper("@COD_MODE_INTV_TO", item.Codigo, DbType.Int32));
                    data.ParameterIn.Add(new ParameterInWrapper("@PRZ_DIA_CURVE", item.PrazoDiaCurva, DbType.Int32));
                    data.ParameterIn.Add(new ParameterInWrapper("@VLR_TOLE_INFE", item.ValorToleranciaInferior, DbType.Decimal));
                    data.ParameterIn.Add(new ParameterInWrapper("@VLR_TOLE_SUPI", item.ValorToleranciaSuperior, DbType.Decimal));

                    returnCode = data.ExecuteNonQuery("DB2IM.IMSJW");

                }
                //Confirma a transação no banco de dados.
                data.CommitTransaction();

            }
            catch (DadosException ex)
            {
                //Retorna as transação no banco 
                data.RollBackTransaction();
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                //Retorna as transação no banco 
                data.RollBackTransaction();
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Finaliza os objetos
                data.Dispose();
                data = null;
            }

        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Matheus Khalil                                                                  <BR/>
        /// DATA DE CRIAÇÃO : 27/01/2011                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método que realiza a exclusão do cadastro do modelo de tunelamento.             <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <param name="modeloIntervaloTolerancia"></param>
        /// <returns></returns>
        public void RemoverIntervaloTolerancia(int codigoModeloIntervaloTolerancia)
        {
            //Declara e instancia os objetos            
            IDataAccessWrapper data = null;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Inicia uma transação no banco de dados.
                data.BeginTransaction();

                // Configura os parâmetro de entrada.
                data.ParameterIn.Add(new ParameterInWrapper("@COD_MODE_INTV_TO", codigoModeloIntervaloTolerancia, DbType.Int32));

                // Recupera os resultados da consulta.
                int returnCode = data.ExecuteNonQuery("DB2IM.IMSLO");

                data.ParameterIn.Clear();
                data.ParameterOut.Clear();

                //Deletar pontos de execuçao tolerancia tunelamento (proc. IMSLP)
                data.ParameterIn.Add(new ParameterInWrapper("@COD_MODE_INTV_TO", codigoModeloIntervaloTolerancia, DbType.Int32));
                returnCode = data.ExecuteNonQuery("DB2IM.IMSLP");

                //Confirma a transação no banco de dados.
                data.CommitTransaction();

            }
            catch (DadosException ex)
            {
                //Retorna as transação no banco 
                data.RollBackTransaction();
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                //Retorna as transação no banco 
                data.RollBackTransaction();
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Finaliza os objetos
                data.Dispose();
                data = null;
            }

        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Cosin                                                                           <BR/>
        /// DATA DE CRIAÇÃO : 01/04/2011                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método que realiza a atualização do cadastro do modelo de tunelamento.          <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <param name="modeloIntervaloTolerancia"></param>
        /// <returns></returns>    
        public List<Curva> ObterCurvasPorNome(string nomeCurva)
        {
            List<Curva> listaCurvas = new List<Curva>();

            //Declara e instancia os objetos            
            IDataAccessWrapper data = null;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                // Configura os parâmetro de entrada.
                data.ParameterIn.Add(new ParameterInWrapper("WNOM_CURV", nomeCurva, DbType.String));

                // Recupera os resultados da consulta.
                DataSet ds = data.ExecuteDataSet("DB2IM.IMS2J");

                // Verifica se é válido o retorno
                if (ds != null && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        // Cria os objetos para adicionar na lista
                        Curva curva = new Curva();

                        // Recupera o objeto e adiciona na lista de retorno.
                        listaCurvas.Add(EntidadeFactory.getObterCurvasPorNome(linha));
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Finaliza os objetos
                data.Dispose();
                data = null;
            }

            return listaCurvas;
        }


        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Cosin                                                                           <BR/>
        /// DATA DE CRIAÇÃO : 01/04/2011                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método que realiza a atualização do cadastro do modelo de tunelamento.          <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <param name="modeloIntervaloTolerancia"></param>
        /// <returns></returns>    
        public List<TipoTaxa> ObterTodosTiposTaxa()
        {
            List<TipoTaxa> lista = new List<TipoTaxa>();
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();
                //Recupera a consulta
                DataSet ds = data.ExecuteDataSet("DB2IM.IMSIK");
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        lista.Add(EntidadeFactory.getTodosTipoTaxa(linha));
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Finaliza os objetos
                data.Dispose();
                data = null;
            }

            return lista;

        }

        public IList<CurvaVigente> ObterCurvasVigentesPMT(int codigoCurvaPMT)
        {
            List<CurvaVigente> lista = new List<CurvaVigente>();
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV_BASE_PMT", codigoCurvaPMT, DbType.Int32));

                DataSet ds = data.ExecuteDataSet("DB2IM.IMS93");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        lista.Add(EntidadeFactory.getCurvaVigentePMT(linha));
                    }
                }

                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                lista = null;
                data.Dispose();
                data = null;
            }

            return lista;
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 12/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método "ObterCurvasVigentePorTipoMesaOrigemCategoriaTipoEntradaFacultativo".    <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <param name="codigoSubmesa">codigoSubmesa</param>
        /// <param name="codigoTipoCurva">codigoTipoCurva</param>
        /// <param name="codigoCategoriaMercado">codigoCategoriaMercado</param>
        /// <param name="codigoSituacaoAtiva">codigoSituacaoAtiva</param>
        /// <param name="codigoSituacaoPendente">codigoSituacaoPendente</param>
        /// <param name="codigoTipoEntradaDado">codigoTipoEntradaDado</param>
        /// <returns>Lista de Curva</returns>
        public IList<Curva> ObterCurvasVigentePorTipoMesaOrigemCategoriaTipoEntradaFacultativo(int codigoSubmesa, int codigoTipoCurva,
            int codigoCategoriaMercado, int codigoSituacaoAtiva, int codigoSituacaoPendente, int codigoTipoEntradaDado)
        {
            //Cria a lista ItemComposicao
            List<Curva> lista = new List<Curva>();

            //Declara o objeto
            IDataAccessWrapper data = null;

            try
            {
                //Instancia o objeto
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_MESA_OPER_TES", codigoSubmesa, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CATE_MERC", codigoCategoriaMercado, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_CURV", codigoTipoCurva, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_SITU1", codigoSituacaoAtiva, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_SITU2", codigoSituacaoPendente, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_TIPO_ENTR_DAD", codigoTipoEntradaDado, DbType.Int32));

                //Recupera a consulta
                DataSet ds = data.ExecuteDataSet("DB2IM.IMS5M");

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        lista.Add(EntidadeFactory.getCurvaObterCurvasVigentePorTipoMesaOrigemCategoriaTipoEntradaFacultativo(linha));
                    }
                }
                //Retorna a consulta
                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                lista = null;
                data.Dispose();
                data = null;
                //ds = null;
            }

            //Retorna a consulta vazia
            return new List<Curva>();
        }

        #endregion


        #region //URICK 26/10/2012

        public IList<Curva> ObterTodasCurvasParaSelecaoEnvioTesouraria()
        {
            List<Curva> lista = new List<Curva>();
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                //URICK ACERTAR NOME DA PROC
                DataSet ds = data.ExecuteDataSet("DB2IM.IMXXX");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        lista.Add(EntidadeFactory.getCurvaParaSelecao(linha));
                    }
                }
                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
                lista = null;
            }

            return new List<Curva>();
        }

        public bool SelecionarCurvasParaEnvioTesouraria(Curva curva)
        {
            IDataAccessWrapper data = null;

            data = EnterpriseLibraryFactory.GetDataAccess();
            try
            {
                data.BeginTransaction();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curva.CodigoCurva, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@IND_ENVO_SIST_TESO", curva.IndicadorEnvioSistemaTesouraria, DbType.Boolean));
                data.ParameterIn.Add(new ParameterInWrapper("@IND_ENVO_VRTE", curva.IndicadorEnvioApenasVertices, DbType.Boolean));

                //URICK AJUSTAR NOME DA PROC
                data.ExecuteNonQuery("DB2IM.IMXXX");
                return true;
            }
            catch (DadosException ex)
            {
                data.RollBackTransaction();
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
                return false;
            }
            catch (Exception ex)
            {
                data.RollBackTransaction();
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
                return false;
            }
            finally
            {
                data.Dispose();
                data = null;
            }
        }

        #endregion
    }
}
